@nice2dev/ui 1.0.5 → 1.0.6

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { ComponentType } from 'react';
 import { Context } from 'react';
 import { CSSProperties } from 'react';
 import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
 import { ForwardedRef } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { HTMLAttributes } from 'react';
@@ -12,6 +13,7 @@ import { PointerEvent as PointerEvent_2 } from 'react';
 import { ReactNode } from 'react';
 import { RefAttributes } from 'react';
 import { RefObject } from 'react';
+import { SetStateAction } from 'react';
 
 declare interface A11yContextValue {
     config: NiceA11yConfig;
@@ -358,6 +360,36 @@ export declare interface Allocation {
 
 export declare const AmazonMarketplaceConnector: ConnectorDefinition;
 
+declare interface AnalyticsContextValue {
+    isActive: boolean;
+    trackEvent: (event: AnalyticsEvent) => void;
+    trackPageView: (event: PageViewEvent) => void;
+    setUserProperties: (properties: Record<string, unknown>) => void;
+    mode: TracelessMode;
+    provider: AnalyticsProvider;
+}
+
+/**
+ * Analytics event type.
+ */
+export declare interface AnalyticsEvent {
+    /** Event name/action */
+    name: string;
+    /** Event category */
+    category?: string;
+    /** Event label */
+    label?: string;
+    /** Event value */
+    value?: number;
+    /** Additional properties */
+    properties?: Record<string, unknown>;
+}
+
+/**
+ * Analytics provider type.
+ */
+export declare type AnalyticsProvider = 'google-analytics' | 'google-tag-manager' | 'matomo' | 'plausible' | 'simple-analytics' | 'umami' | 'fathom' | 'pirsch' | 'custom';
+
 /**
  * Animation timing presets
  */
@@ -609,6 +641,12 @@ export declare interface AudioEncodingSettings {
     loudnessTarget?: number;
 }
 
+/**
+ * Audit scanner: checks if any storage is being used against policy.
+ * Returns violations found.
+ */
+export declare function auditStorageCompliance(policy: ITracelessPolicy): StorageAuditResult;
+
 /**
  * Run a comprehensive WCAG 2.2 AAA audit on the current document.
  */
@@ -2791,6 +2829,24 @@ export declare interface CurrencyDef {
 /** Current schema version. */
 export declare const CURRENT_SCHEMA_VERSION = 2;
 
+/**
+ * Custom analytics handler for 'custom' provider.
+ */
+export declare interface CustomAnalyticsHandler {
+    /** Initialize analytics */
+    init: () => void | Promise<void>;
+    /** Track page view */
+    trackPageView: (event: PageViewEvent) => void;
+    /** Track custom event */
+    trackEvent: (event: AnalyticsEvent) => void;
+    /** Set user properties */
+    setUserProperties?: (properties: Record<string, unknown>) => void;
+    /** Opt out of tracking */
+    optOut?: () => void;
+    /** Opt in to tracking */
+    optIn?: () => void;
+}
+
 export declare interface CustomEmoji {
     id: string;
     name: string;
@@ -3749,6 +3805,23 @@ export declare const DynamicsBCConnector: ConnectorDefinition;
 
 export declare const EBayConnector: ConnectorDefinition;
 
+/**
+ * State type for text editor persistence (drafts, history, etc.)
+ */
+export declare interface EditorPersistentState {
+    content?: string;
+    cursorPosition?: {
+        line: number;
+        column: number;
+    };
+    selectionRange?: {
+        start: number;
+        end: number;
+    };
+    lastModified?: number;
+    version?: number;
+}
+
 export declare interface EllipseAnnotation extends AnnotationBase {
     tool: 'ellipse';
 }
@@ -5147,6 +5220,11 @@ export declare function generateTokens(tokens: FlatTokenMap, format: TokenFormat
 /** Generate tooltip styles */
 export declare function generateTooltipStyles(variant: TooltipStyleVariant): Record<string, string>;
 
+/**
+ * Generates a compliance report for the current traceless configuration.
+ */
+export declare function generateTracelessComplianceReport(policy: ITracelessPolicy, instanceId: string, tenantId?: string): TracelessComplianceReport;
+
 /** Generate a TypeScript interface from a view definition's data bindings. */
 export declare function generateTypescriptModel(view: NiceViewDefinitionV2): NiceGeneratedFile;
 
@@ -5275,6 +5353,11 @@ export declare function getRecentTimings(limit?: number): RenderTiming[];
  */
 export declare function getSlowRenders(thresholdMs?: number): RenderTiming[];
 
+/**
+ * Gets badge display info for the current mode.
+ */
+export declare function getTracelessBadgeInfo(policy: ITracelessPolicy): TracelessBadgeInfo;
+
 export declare interface GitBlameEntry {
     lineStart: number;
     lineEnd: number;
@@ -5470,6 +5553,20 @@ export declare interface GridColumnPreference {
     cellColor?: string;
 }
 
+/**
+ * State type for NiceDataGrid persistence.
+ */
+export declare interface GridPersistentState {
+    columnWidths?: Record<string, number>;
+    columnOrder?: string[];
+    sortField?: string;
+    sortDirection?: 'asc' | 'desc' | null;
+    pageSize?: number;
+    expandedGroups?: string[];
+    filters?: Record<string, any>;
+    hiddenColumns?: string[];
+}
+
 /**
  * Grid preferences
  */
@@ -5492,6 +5589,20 @@ export declare interface GridPreferences {
     rowColors?: Record<string | number, string>;
 }
 
+/**
+ * Options for useGridStatePersistence hook.
+ */
+export declare interface GridStatePersistenceOptions {
+    /** Unique storage key for this grid instance */
+    storageKey: string;
+    /** Initial state (used when no saved state exists) */
+    initialState?: GridPersistentState;
+    /** Callback when state changes */
+    onStateChange?: (state: GridPersistentState) => void;
+    /** Specific storage type override */
+    storageType?: 'local' | 'session' | 'auto';
+}
+
 /**
  * Groups data by specified fields with optional aggregation.
  */
@@ -5646,6 +5757,56 @@ export declare type HeaderVariant = 'default' | 'transparent' | 'blur' | 'solid'
 /** Health check severity levels. */
 export declare type HealthSeverity = 'error' | 'warning' | 'info';
 
+export declare interface HelpConfig {
+    /** Global enable/disable for all inline help */
+    enabled: boolean;
+    /** Default visibility for help panels (collapsed/expanded) */
+    defaultExpanded: boolean;
+    /** Show help icon in component headers */
+    showHelpIcon: boolean;
+    /** Help panel position */
+    position: 'top' | 'bottom' | 'tooltip' | 'sidebar';
+    /** Locale for help content */
+    locale: string;
+    /** Custom help content loader */
+    contentLoader?: (componentName: string, locale: string) => Promise<HelpContent | null>;
+}
+
+export declare interface HelpContent {
+    name: string;
+    description: string;
+    category: string;
+    version?: string;
+    since?: string;
+    status?: 'stable' | 'beta' | 'deprecated';
+    author?: string;
+    props?: HelpProp[];
+    examples?: HelpExample[];
+    tips?: string[];
+    seeAlso?: string[];
+}
+
+export declare interface HelpContextValue {
+    /** Current help configuration */
+    config: HelpConfig;
+    /** Update help configuration */
+    setConfig: (config: Partial<HelpConfig>) => void;
+    /** Toggle global help visibility */
+    toggleGlobalHelp: () => void;
+    /** Per-component disabled set */
+    disabledComponents: Set<string>;
+    /** Disable help for specific component */
+    disableComponentHelp: (componentName: string) => void;
+    /** Enable help for specific component */
+    enableComponentHelp: (componentName: string) => void;
+    /** Check if help is enabled for component */
+    isHelpEnabled: (componentName: string) => boolean;
+    /** Get help content for component */
+    getHelpContent: (componentName: string) => Promise<HelpContent | null>;
+    /** Loaded help content cache */
+    helpCache: Map<string, HelpContent>;
+}
+
 declare interface HelpDeskAttachment {
     id: string;
     filename: string;
@@ -5737,6 +5898,20 @@ declare interface HelpDeskUser {
 
 declare type HelpDeskView = 'list' | 'detail' | 'create' | 'dashboard' | 'knowledge-base' | 'settings';
 
+export declare interface HelpExample {
+    title: string;
+    code: string;
+    language?: string;
+}
+
+export declare interface HelpProp {
+    name: string;
+    type: string;
+    required?: boolean;
+    default?: string | number | boolean;
+    description: string;
+}
+
 /**
  * Hero header with background image
  */
@@ -6032,6 +6207,31 @@ export declare function isVibrationSupported(): boolean;
 /** Check if a view is compatible with a given platform. */
 export declare function isViewCompatibleWith(view: NiceCrossPlatformView, platform: NicePlatformCapability): boolean;
 
+/**
+ * Main policy interface for Traceless system.
+ * Three independent flags for granular control.
+ */
+export declare interface ITracelessPolicy {
+    /** Whether cookies are allowed (any cookies) */
+    cookiesAllowed: boolean;
+    /** Whether localStorage is allowed */
+    localStorageAllowed: boolean;
+    /** Whether sessionStorage is allowed */
+    sessionStorageAllowed: boolean;
+    /** Whether only strictly necessary auth cookie is allowed (httpOnly) */
+    strictAuthCookieOnly: boolean;
+    /** The effective mode derived from flags */
+    effectiveMode: TracelessMode;
+    /** Source of the policy (instance, tenant, group, user) */
+    source: TracelessPolicySource;
+    /** Whether consent banner should be shown */
+    requiresConsentBanner: boolean;
+    /** Timestamp when policy was resolved */
+    resolvedAt: number;
+    /** Policy version for cache invalidation */
+    version: string;
+}
+
 /** Job priority */
 export declare type JobPriority = 'low' | 'normal' | 'high' | 'urgent';
 
@@ -7837,6 +8037,63 @@ export declare interface NiceAmountBreakdownProps extends NiceFormFieldProps {
     compact?: boolean;
 }
 
+/**
+ * NiceAnalyticsTracker — Traceless-aware analytics wrapper.
+ *
+ * @example
+ * ```tsx
+ * // Wrap your app
+ * <NiceAnalyticsTracker
+ *   provider="plausible"
+ *   trackingId="your-domain.com"
+ *   autoTrackPageViews
+ * >
+ *   <App />
+ * </NiceAnalyticsTracker>
+ *
+ * // Or use the hook in components
+ * const { trackEvent, isActive } = useAnalytics();
+ * trackEvent({ name: 'button_click', category: 'engagement' });
+ * ```
+ */
+export declare function NiceAnalyticsTracker({ children, provider, trackingId, endpoint, customHandler, cookies, localStorage, minMode, autoTrackPageViews, respectDoNotTrack, debug, domain, scriptUrl, anonymizeIp, cookieless, }: NiceAnalyticsTrackerProps): default_2.ReactElement | null;
+
+/**
+ * Props for NiceAnalyticsTracker.
+ */
+export declare interface NiceAnalyticsTrackerProps {
+    /** Children to render (optional - can be used as wrapper or standalone) */
+    children?: ReactNode;
+    /** Analytics provider */
+    provider: AnalyticsProvider;
+    /** Provider-specific ID (e.g., GA measurement ID) */
+    trackingId?: string;
+    /** Provider endpoint URL (for self-hosted solutions) */
+    endpoint?: string;
+    /** Custom handler for 'custom' provider */
+    customHandler?: CustomAnalyticsHandler;
+    /** Whether this component may use cookies */
+    cookies?: boolean;
+    /** Whether this component may use localStorage */
+    localStorage?: boolean;
+    /** Minimum mode required for tracking to be active */
+    minMode?: TracelessMode;
+    /** Auto-track page views */
+    autoTrackPageViews?: boolean;
+    /** Respect Do Not Track header */
+    respectDoNotTrack?: boolean;
+    /** Debug mode - logs events to console */
+    debug?: boolean;
+    /** Domain for analytics (for cross-domain tracking) */
+    domain?: string;
+    /** Custom script URL override */
+    scriptUrl?: string;
+    /** Anonymize IP addresses */
+    anonymizeIp?: boolean;
+    /** Disable cookies (use cookieless tracking) */
+    cookieless?: boolean;
+}
+
 export declare interface NiceAnimationConfig {
     /** Animation preset or 'none' to disable */
     type: NiceAnimationPreset;
@@ -8614,7 +8871,7 @@ export declare const NiceCalculatorKeyboard: default_2.ForwardRefExoticComponent
 export declare const NiceCalendar: default_2.FC<NiceCalendarProps>;
 
 /** Props for the {@link NiceCalendar} component — an inline month calendar with day/month/year views and multi-select support. */
-export declare interface NiceCalendarProps extends NiceBaseProps {
+export declare interface NiceCalendarProps extends NiceBaseProps, TracelessStorageProps {
     /** Single selected date (ISO). Use together with onChange for single-select mode. */
     value?: string;
     onChange?: (date: string) => void;
@@ -8634,6 +8891,8 @@ export declare interface NiceCalendarProps extends NiceBaseProps {
     renderDay?: (date: string, day: number) => default_2.ReactNode;
     /** Show keyboard hints. */
     showKeyboardHints?: boolean;
+    /** Persist view preferences (requires Traceless storage props) */
+    persistPreferences?: boolean;
 }
 
 export declare type NiceCalendarView = 'days' | 'months' | 'years' | 'decade';
@@ -9695,6 +9954,35 @@ export declare interface NiceConnectorSelectorProps extends NiceBaseProps {
     disabledConnectors?: string[];
 }
 
+/**
+ * Cookie/storage consent banner that auto-hides based on Traceless policy.
+ */
+export declare function NiceConsentBanner({ className, position, variant, onAccept, onDecline, onCustomize, privacyPolicyUrl, acceptText, declineText, }: NiceConsentBannerProps): default_2.ReactElement | null;
+
+/**
+ * Props for NiceConsentBanner.
+ */
+export declare interface NiceConsentBannerProps {
+    /** Custom class name */
+    className?: string;
+    /** Position */
+    position?: 'top' | 'bottom';
+    /** Theme variant */
+    variant?: 'minimal' | 'detailed';
+    /** Callback when consent is given */
+    onAccept?: () => void;
+    /** Callback when consent is declined */
+    onDecline?: () => void;
+    /** Callback when user wants to customize */
+    onCustomize?: () => void;
+    /** Privacy policy URL */
+    privacyPolicyUrl?: string;
+    /** Custom accept button text */
+    acceptText?: string;
+    /** Custom decline button text */
+    declineText?: string;
+}
+
 /**
  * {@link NiceConsentPanel} — GDPR/terms consent tracking panel with individual
  * accept/reject toggles, required consent markers, bulk actions, and confirm button.
@@ -12961,6 +13249,32 @@ export declare interface NiceHelpDeskProps extends NiceBaseProps {
     onExportTickets?: (filter: TicketFilter, format: 'csv' | 'xlsx' | 'pdf') => Promise<void>;
 }
 
+/**
+ * Help icon that shows help content on click
+ */
+export declare const NiceHelpIcon: default_2.FC<NiceHelpIconProps>;
+
+export declare interface NiceHelpIconProps {
+    /** Help content to show */
+    content: string | HelpContent;
+    /** Button size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Custom className */
+    className?: string;
+    /** Callback when help is opened */
+    onOpen?: () => void;
+}
+
+export declare const NiceHelpProvider: default_2.FC<NiceHelpProviderProps>;
+
+export declare interface NiceHelpProviderProps {
+    children: ReactNode;
+    /** Initial configuration */
+    config?: Partial<HelpConfig>;
+    /** Preloaded help content */
+    helpContent?: Record<string, HelpContent>;
+}
+
 /**
  * Conditionally hide content based on breakpoint
  *
@@ -13450,6 +13764,37 @@ export declare interface NiceInfiniteScrollState<T> {
     totalCount: number;
 }
 
+export declare const NiceInlineHelp: default_2.FC<NiceInlineHelpProps>;
+
+export declare interface NiceInlineHelpProps {
+    /** Component name for help lookup */
+    componentName: string;
+    /** Override help content (instead of loading from .doc.json) */
+    content?: HelpContent;
+    /** Custom children to render inside help panel */
+    children?: ReactNode;
+    /** Position override */
+    position?: 'top' | 'bottom' | 'tooltip' | 'inline';
+    /** Initial expanded state */
+    defaultExpanded?: boolean;
+    /** Disable help for this instance */
+    disabled?: boolean;
+    /** Additional className */
+    className?: string;
+    /** Custom trigger icon */
+    icon?: ReactNode;
+    /** Title override */
+    title?: string;
+    /** Show props table */
+    showProps?: boolean;
+    /** Show examples */
+    showExamples?: boolean;
+    /** Show tips */
+    showTips?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+}
+
 export declare const NiceInPlaceEditor: default_2.ForwardRefExoticComponent<NiceInPlaceEditorProps & default_2.RefAttributes<HTMLDivElement>>;
 
 declare interface NiceInPlaceEditorOption {
@@ -13606,7 +13951,7 @@ declare interface NiceJSONOptions extends NiceExportOptions {
 export declare const NiceKanbanBoard: default_2.ForwardRefExoticComponent<NiceKanbanBoardProps & default_2.RefAttributes<HTMLDivElement>>;
 
 /** Props for the {@link NiceKanbanBoard} component — a drag-and-drop kanban board with columns, WIP limits, and custom card rendering. */
-export declare interface NiceKanbanBoardProps extends NiceBaseProps {
+export declare interface NiceKanbanBoardProps extends NiceBaseProps, TracelessStorageProps {
     /** Column definitions. */
     columns: NiceKanbanColumn[];
     /** Card data. */
@@ -13623,6 +13968,16 @@ export declare interface NiceKanbanBoardProps extends NiceBaseProps {
     disabled?: boolean;
     /** Size preset. */
     size?: NiceSize;
+    /** Allow columns to be collapsed */
+    collapsible?: boolean;
+    /** View mode (default, compact, detailed) */
+    viewMode?: NiceKanbanViewMode;
+    /** Callback when view mode changes */
+    onViewModeChange?: (mode: NiceKanbanViewMode) => void;
+    /** Initial collapsed columns (controlled) */
+    collapsedColumns?: (string | number)[];
+    /** Callback when collapsed columns change */
+    onCollapsedColumnsChange?: (keys: (string | number)[]) => void;
 }
 
 /** A card on the {@link NiceKanbanBoard}. */
@@ -13653,6 +14008,19 @@ export declare interface NiceKanbanColumn {
     limit?: number;
 }
 
+/** Persisted state for NiceKanbanBoard */
+export declare interface NiceKanbanPersistedState {
+    /** Collapsed column keys */
+    collapsedColumns?: (string | number)[];
+    /** Current view mode */
+    viewMode?: NiceKanbanViewMode;
+    /** Custom column widths (key -> width) */
+    columnWidths?: Record<string, number>;
+}
+
+/** Display mode for kanban cards */
+export declare type NiceKanbanViewMode = 'default' | 'compact' | 'detailed';
+
 /**
  * A small question mark icon that shows keyboard shortcuts on hover.
  * Use this to inform users about available keyboard interactions.
@@ -17037,6 +17405,22 @@ export declare interface NiceQuickAction {
     shortcut?: string;
 }
 
+/**
+ * Lightweight inline help that shows on hover/focus
+ */
+export declare const NiceQuickHelp: default_2.FC<NiceQuickHelpProps>;
+
+export declare interface NiceQuickHelpProps {
+    /** Help text to display */
+    text: string;
+    /** Help position */
+    position?: 'top' | 'right' | 'bottom' | 'left';
+    /** Custom className */
+    className?: string;
+    /** Trigger element */
+    children: ReactNode;
+}
+
 /**
  * NiceQuiz — Interactive quiz component with gamification features
  *
@@ -19850,6 +20234,55 @@ export declare interface NiceThemeSpacing {
     space16?: string;
 }
 
+/**
+ * NiceThemeSwitcher — Traceless-aware theme selection component.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with themes
+ * <NiceThemeSwitcher
+ *   themes={[
+ *     { key: 'light', label: 'Light', icon: '☀️', theme: lightTheme },
+ *     { key: 'dark', label: 'Dark', icon: '🌙', theme: darkTheme },
+ *   ]}
+ * />
+ *
+ * // In traceless mode (no persistence)
+ * <NiceThemeSwitcher themes={myThemes} storageMode="traceless" />
+ * ```
+ */
+export declare function NiceThemeSwitcher({ variant, themes, size, showLabels, onThemeChange, defaultTheme, showSystemOption, className, style, disabled, label, hideLabel, cookies, localStorage, sessionStorage, storageMode, storageKey, }: NiceThemeSwitcherProps): default_2.ReactElement;
+
+/**
+ * Props for NiceThemeSwitcher.
+ */
+export declare interface NiceThemeSwitcherProps extends ThemeSwitcherStorageProps {
+    /** Display variant */
+    variant?: ThemeSwitcherVariant;
+    /** Available theme options (required - define your light/dark themes) */
+    themes: ThemeOption[];
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show labels (only applies to 'icons' and 'buttons' variants) */
+    showLabels?: boolean;
+    /** Callback when theme changes */
+    onThemeChange?: (theme: NiceTheme, key: string) => void;
+    /** Default theme key (if not persisted or in traceless mode) */
+    defaultTheme?: string;
+    /** Show "System" option that follows OS preference */
+    showSystemOption?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Label for the switcher */
+    label?: string;
+    /** Hide label visually (still accessible) */
+    hideLabel?: boolean;
+}
+
 /** Text colour levels. */
 export declare interface NiceThemeText {
     primary: string;
@@ -22885,6 +23318,20 @@ export declare interface PackageDoc {
     }>;
 }
 
+/**
+ * Page view event.
+ */
+export declare interface PageViewEvent {
+    /** Page path */
+    path: string;
+    /** Page title */
+    title?: string;
+    /** Referrer */
+    referrer?: string;
+    /** Additional properties */
+    properties?: Record<string, unknown>;
+}
+
 /**
  * Panel customization.
  */
@@ -23277,6 +23724,11 @@ export declare type PreloadFn = () => Promise<void>;
  */
 export declare function printPerformanceReport(): void;
 
+/**
+ * Privacy level ordering (lower index = more private).
+ */
+export declare const PRIVACY_LEVEL_ORDER: TracelessMode[];
+
 export declare interface ProcessIncident {
     id: string;
     instanceId: string;
@@ -23942,6 +24394,12 @@ export declare function resolveDisplayStyleConfig(style: NiceDisplayStyle): Them
 /** Resolve permissions for a set of user roles. */
 export declare function resolvePermissions(userRoleIds: string[], policy: NiceRbacPolicy): NiceResolvedPermissions;
 
+/**
+ * Resolves effective policy from hierarchy.
+ * Instance ceiling → Tenant policy → Group policy → User preference
+ */
+export declare function resolveTracelessPolicy(instanceCeiling: TracelessInstanceCeiling, tenantPolicy?: TracelessTenantPolicy, groupPolicy?: TracelessGroupPolicy, userPreference?: TracelessUserPreference): ITracelessPolicy;
+
 export declare interface Resource {
     id: string;
     name: string;
@@ -25052,6 +25510,99 @@ export declare function startMark(name: string, detail?: Record<string, unknown>
 /** Predefined status semantic categories. */
 export declare type StatusCategory = 'success' | 'warning' | 'error' | 'info' | 'neutral' | 'custom';
 
+/**
+ * Unified storage adapter that respects Traceless policy.
+ * Gracefully degrades based on what's available.
+ */
+export declare class StorageAdapter {
+    private policy;
+    private namespace;
+    private defaultBackend;
+    constructor(policy: ITracelessPolicy, namespace?: string, defaultBackend?: StorageBackendType);
+    /**
+     * Gets the appropriate storage backend based on policy.
+     */
+    private getBackend;
+    /**
+     * Gets the prefixed key.
+     */
+    private getKey;
+    /**
+     * Gets a value from storage.
+     */
+    get<T = string>(key: string, preferredBackend?: StorageBackendType): T | null;
+    /**
+     * Sets a value in storage.
+     * Silently no-ops if storage is not available (graceful degradation).
+     */
+    set(key: string, value: unknown, preferredBackend?: StorageBackendType): boolean;
+    /**
+     * Removes a value from storage.
+     */
+    remove(key: string, preferredBackend?: StorageBackendType): boolean;
+    /**
+     * Clears all namespaced values from storage.
+     */
+    clear(preferredBackend?: StorageBackendType): void;
+    /**
+     * Gets all keys in the namespace.
+     */
+    keys(preferredBackend?: StorageBackendType): string[];
+    /**
+     * Checks if a key exists.
+     */
+    has(key: string, preferredBackend?: StorageBackendType): boolean;
+    /**
+     * Gets info about current storage capabilities.
+     */
+    getCapabilities(): StorageCapabilities;
+    /**
+     * Gets the actual backend type being used.
+     */
+    private getActualBackendType;
+    /**
+     * Updates the policy (e.g., after user changes preferences).
+     */
+    updatePolicy(policy: ITracelessPolicy): void;
+}
+
+/**
+ * Storage audit result.
+ */
+export declare interface StorageAuditResult {
+    compliant: boolean;
+    violations: StorageViolation[];
+    auditedAt: number;
+    policy: TracelessMode;
+}
+
+/**
+ * Storage backend type.
+ */
+export declare type StorageBackendType = 'memory' | 'session' | 'local';
+
+/**
+ * Storage capabilities info.
+ */
+declare interface StorageCapabilities {
+    canUseCookies: boolean;
+    canUseLocalStorage: boolean;
+    canUseSessionStorage: boolean;
+    canPersist: boolean;
+    effectiveMode: TracelessMode;
+    actualBackend: StorageBackendType;
+}
+
+/**
+ * Storage violation entry.
+ */
+export declare interface StorageViolation {
+    type: 'cookie' | 'localStorage' | 'sessionStorage';
+    severity: 'low' | 'medium' | 'high';
+    message: string;
+    data?: string;
+}
+
 /** Stream analytics */
 export declare interface StreamAnalytics {
     totalViewers: number;
@@ -25681,6 +26232,22 @@ export declare const themeOneDark: NiceTheme;
 
 export declare const themeOnyx: NiceTheme;
 
+/**
+ * Theme option for the switcher.
+ */
+export declare interface ThemeOption {
+    /** Unique key */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Icon or emoji */
+    icon?: default_2.ReactNode;
+    /** The theme object */
+    theme: NiceTheme;
+    /** Whether this is the system theme (follows OS preference) */
+    isSystem?: boolean;
+}
+
 export declare const themeOrange: NiceTheme;
 
 export declare const themePastelCoral: NiceTheme;
@@ -25701,6 +26268,11 @@ export declare const themePastelSky: NiceTheme;
 
 export declare const themePink: NiceTheme;
 
+/**
+ * Built-in theme presets.
+ */
+export declare type ThemePreset = 'light' | 'dark' | 'system' | 'custom';
+
 export declare const themeRealEstate: NiceTheme;
 
 export declare const themeRetrowave: NiceTheme;
@@ -25735,6 +26307,27 @@ export declare const themeSummerBeach: NiceTheme;
 
 export declare const themeSunset: NiceTheme;
 
+/**
+ * Traceless storage props interface for theme switcher.
+ */
+declare interface ThemeSwitcherStorageProps {
+    /** Whether this component may use cookies */
+    cookies?: boolean;
+    /** Whether this component may use localStorage */
+    localStorage?: boolean;
+    /** Whether this component may use sessionStorage */
+    sessionStorage?: boolean;
+    /** Override storage mode for this component */
+    storageMode?: TracelessMode;
+    /** Storage key for persisting component state */
+    storageKey?: string;
+}
+
+/**
+ * Display variant for the theme switcher.
+ */
+export declare type ThemeSwitcherVariant = 'dropdown' | 'radio' | 'buttons' | 'icons';
+
 export declare const themeSynthwave: NiceTheme;
 
 export declare const themeTeal: NiceTheme;
@@ -26151,6 +26744,360 @@ export declare interface TouchTargetProps {
     onClick?: () => void;
 }
 
+/**
+ * Default values for Traceless storage props (safe by default).
+ */
+export declare const TRACELESS_DEFAULT_PROPS: Record<string, unknown>;
+
+/**
+ * Policy presets for each mode.
+ */
+export declare const TRACELESS_MODE_PRESETS: Record<TracelessMode, Omit<ITracelessPolicy, 'source' | 'resolvedAt' | 'version'>>;
+
+/**
+ * Standard Traceless storage prop descriptors.
+ * Add these to any control that can persist state.
+ */
+export declare const TRACELESS_PROP_DESCRIPTORS: NiceConfiguratorPropDescriptor[];
+
+/**
+ * Displays current Traceless mode with visual indicator.
+ *
+ * @example
+ * ```tsx
+ * <TracelessBadge showTooltip onClick={() => openPrivacySettings()} />
+ * ```
+ */
+export declare function TracelessBadge({ className, size, showTooltip, showLabel, onClick, label: customLabel, tooltipPosition, }: TracelessBadgeProps): default_2.ReactElement;
+
+/**
+ * Badge display info for TracelessBadge component.
+ */
+export declare interface TracelessBadgeInfo {
+    mode: TracelessMode;
+    icon: string;
+    color: string;
+    label: string;
+    tooltip: string;
+    cssClass: string;
+}
+
+/**
+ * Props for TracelessBadge component.
+ */
+export declare interface TracelessBadgeProps {
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show tooltip on hover */
+    showTooltip?: boolean;
+    /** Show label text */
+    showLabel?: boolean;
+    /** Click handler (e.g., to open settings) */
+    onClick?: () => void;
+    /** Custom label override */
+    label?: string;
+    /** Position for tooltip */
+    tooltipPosition?: 'top' | 'bottom' | 'left' | 'right';
+}
+
+/**
+ * Compliance report structure.
+ */
+export declare interface TracelessComplianceReport {
+    generatedAt: string;
+    instanceId: string;
+    tenantId?: string;
+    effectiveMode: TracelessMode;
+    cookies: {
+        count: number;
+        allowed: boolean;
+        strictAuthOnly: boolean;
+        thirdParty: boolean;
+        tracking: boolean;
+    };
+    localStorage: {
+        bytesUsed: number;
+        allowed: boolean;
+        keysCount: number;
+    };
+    sessionStorage: {
+        bytesUsed: number;
+        allowed: boolean;
+        keysCount: number;
+    };
+    consentBanner: {
+        required: boolean;
+        shown: boolean;
+    };
+    compliance: {
+        ePrivacyCompliant: boolean;
+        gdprCompliant: boolean;
+        pecrCompliant: boolean;
+    };
+    statement: string;
+}
+
+/**
+ * Traceless context value.
+ */
+export declare interface TracelessContextValue {
+    /** Current effective policy */
+    policy: ITracelessPolicy;
+    /** Whether cookies are allowed */
+    canUseCookies: boolean;
+    /** Whether localStorage is allowed */
+    canUseLocalStorage: boolean;
+    /** Whether sessionStorage is allowed */
+    canUseSessionStorage: boolean;
+    /** Whether data can be persisted across sessions */
+    canPersist: boolean;
+    /** Current mode */
+    mode: TracelessMode;
+    /** Whether consent banner should be shown */
+    requiresConsentBanner: boolean;
+    /** Badge info for UI display */
+    badgeInfo: TracelessBadgeInfo;
+    /** Update user preference (can only increase privacy) */
+    setUserPreference: (preference: Partial<TracelessUserPreference>) => void;
+    /** Generate compliance report */
+    generateReport: () => TracelessComplianceReport;
+    /** Run storage audit */
+    runAudit: () => StorageAuditResult;
+    /** Force refresh policy from API */
+    refreshPolicy: () => Promise<void>;
+    /** Get storage adapter for a namespace */
+    getStorageAdapter: (namespace?: string) => StorageAdapter;
+    /** Whether policy is still loading */
+    isLoading: boolean;
+    /** Error if policy fetch failed */
+    error: Error | null;
+}
+
+/**
+ * User group policy.
+ */
+declare interface TracelessGroupPolicy {
+    groupId: string;
+    tenantId: string;
+    /** Policy mode (cannot exceed tenant policy) */
+    mode: TracelessMode;
+    /** Allow users in this group to self-lockdown? */
+    allowUserLockdown: boolean;
+}
+
+/**
+ * Instance-level ceiling configuration.
+ * Sets the maximum permissions any tenant/user can have.
+ */
+declare interface TracelessInstanceCeiling {
+    /** Maximum cookie permission for all tenants */
+    maxCookies: boolean;
+    /** Maximum localStorage permission for all tenants */
+    maxLocalStorage: boolean;
+    /** Maximum sessionStorage permission for all tenants */
+    maxSessionStorage: boolean;
+    /** Instance-wide default mode */
+    defaultMode: TracelessMode;
+    /** Allow tenants to override? */
+    allowTenantOverride: boolean;
+    /** Instance ID for audit */
+    instanceId: string;
+}
+
+/**
+ * @fileoverview Traceless™ — Zero-Trace Privacy Architecture
+ * @module @nice2dev/ui/core/traceless
+ *
+ * Traceless™ is OmniVerk's flagship privacy feature that allows complete control
+ * over client-side storage (cookies, localStorage, sessionStorage).
+ *
+ * "Żadnych śladów. Żadnych cookies. Żadnego localStorage. Żadnego bannera. Traceless."
+ *
+ * @example
+ * ```tsx
+ * import { TracelessProvider, useTracelessPolicy, StorageAdapter } from '@nice2dev/ui';
+ *
+ * // In your app root:
+ * <TracelessProvider>
+ *   <App />
+ * </TracelessProvider>
+ *
+ * // In components:
+ * const { mode, canUseCookies, canUseLocalStorage } = useTracelessPolicy();
+ * const storage = useStorageAdapter();
+ * storage.set('key', 'value'); // Automatically respects policy
+ * ```
+ */
+/**
+ * Privacy storage modes from most private to most permissive.
+ *
+ * | Mode       | Cookies | localStorage | sessionStorage | Consent Banner |
+ * |------------|---------|--------------|----------------|----------------|
+ * | traceless  | ❌      | ❌           | ❌             | ❌ Never       |
+ * | ephemeral  | ❌      | ❌           | ✅             | ❌ Never       |
+ * | private    | 1 auth  | ❌           | ✅             | ❌ Exempt      |
+ * | balanced   | ❌      | ✅           | ✅             | ⚠️ Maybe       |
+ * | full       | ✅      | ✅           | ✅             | ✅ Required    |
+ * | custom     | Config  | Config       | Config         | Config         |
+ */
+export declare type TracelessMode = 'traceless' | 'ephemeral' | 'private' | 'balanced' | 'full' | 'custom';
+
+/**
+ * Full privacy settings panel.
+ */
+export declare function TracelessPanel({ className, showReport, showAudit, showModeSelector, availableModes, onModeChange, }: TracelessPanelProps): default_2.ReactElement;
+
+/**
+ * Props for TracelessPanel component.
+ */
+export declare interface TracelessPanelProps {
+    /** Custom class name */
+    className?: string;
+    /** Show compliance report */
+    showReport?: boolean;
+    /** Show audit results */
+    showAudit?: boolean;
+    /** Show mode selector */
+    showModeSelector?: boolean;
+    /** Available modes to select from */
+    availableModes?: TracelessMode[];
+    /** Callback when user changes mode */
+    onModeChange?: (mode: TracelessMode) => void;
+}
+
+/**
+ * Source hierarchy for policy resolution.
+ * Lower sources cannot exceed permissions of higher sources.
+ */
+export declare type TracelessPolicySource = 'instance' | 'tenant' | 'group' | 'user' | 'control' | 'default';
+
+/**
+ * Provider component for Traceless context.
+ */
+export declare function TracelessProvider({ children, initialPolicy, policyEndpoint, instanceCeiling, tenantPolicy, groupPolicy, userPreference: initialUserPreference, instanceId, tenantId, onPolicyChange, }: TracelessProviderProps): default_2.ReactElement;
+
+/**
+ * Props for TracelessProvider.
+ */
+export declare interface TracelessProviderProps {
+    children: ReactNode;
+    /**
+     * Initial policy to use before fetching from API.
+     * Defaults to most restrictive (traceless).
+     */
+    initialPolicy?: ITracelessPolicy;
+    /**
+     * API endpoint to fetch policy from.
+     * If not provided, uses initialPolicy or default.
+     */
+    policyEndpoint?: string;
+    /**
+     * Instance ceiling configuration.
+     * If not provided, uses permissive defaults.
+     */
+    instanceCeiling?: TracelessInstanceCeiling;
+    /**
+     * Tenant policy configuration.
+     */
+    tenantPolicy?: TracelessTenantPolicy;
+    /**
+     * Group policy configuration.
+     */
+    groupPolicy?: TracelessGroupPolicy;
+    /**
+     * User preference configuration.
+     */
+    userPreference?: TracelessUserPreference;
+    /**
+     * Instance ID for reports.
+     */
+    instanceId?: string;
+    /**
+     * Tenant ID for reports.
+     */
+    tenantId?: string;
+    /**
+     * Callback when policy changes.
+     */
+    onPolicyChange?: (policy: ITracelessPolicy) => void;
+}
+
+/**
+ * Standard props that can be added to any component to support Traceless policy.
+ */
+export declare interface TracelessStorageProps {
+    /** Whether this component may use cookies */
+    cookies?: boolean;
+    /** Whether this component may use localStorage */
+    localStorage?: boolean;
+    /** Whether this component may use sessionStorage */
+    sessionStorage?: boolean;
+    /** Override storage mode for this component */
+    storageMode?: TracelessMode;
+    /** Storage key for persisting component state */
+    storageKey?: string;
+}
+
+/**
+ * Tenant-level policy configuration.
+ */
+declare interface TracelessTenantPolicy {
+    tenantId: string;
+    /** Policy mode (cannot exceed instance ceiling) */
+    mode: TracelessMode;
+    /** Custom overrides */
+    customPolicy?: Partial<ITracelessPolicy>;
+    /** Allow user groups to override? */
+    allowGroupOverride: boolean;
+    /** Allow individual users to override? */
+    allowUserOverride: boolean;
+    /** Last updated timestamp */
+    updatedAt: number;
+    /** Updated by user ID */
+    updatedBy?: string;
+}
+
+/**
+ * User self-lockdown configuration.
+ * Users can only INCREASE privacy, never decrease it.
+ */
+declare interface TracelessUserPreference {
+    userId: string;
+    /** User's preferred mode (must be >= group mode in privacy) */
+    preferredMode: TracelessMode;
+    /** Explicit overrides (can only restrict, not permit) */
+    restrictCookies?: boolean;
+    restrictLocalStorage?: boolean;
+    restrictSessionStorage?: boolean;
+    /** When user set this preference */
+    setAt: number;
+}
+
+/**
+ * Shows warning when functionality is degraded due to privacy settings.
+ */
+export declare function TracelessWarning({ useCase, className, message: customMessage, variant, dismissible, onDismiss, }: TracelessWarningProps): default_2.ReactElement | null;
+
+/**
+ * Props for TracelessWarning.
+ */
+export declare interface TracelessWarningProps {
+    /** Use case type */
+    useCase: 'preferences' | 'draft' | 'history' | 'auth' | 'grid-state';
+    /** Custom class name */
+    className?: string;
+    /** Custom message override */
+    message?: string;
+    /** Variant */
+    variant?: 'inline' | 'banner' | 'toast';
+    /** Show dismiss button */
+    dismissible?: boolean;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+}
+
 export declare interface Track {
     id: string;
     type: TrackType;
@@ -26475,6 +27422,11 @@ declare interface UseAICompletionResult {
     clearHistory: () => void;
 }
 
+/**
+ * Hook to access analytics tracking functions.
+ */
+export declare function useAnalytics(): AnalyticsContextValue;
+
 export declare function useAuditLog(options?: UseAuditLogOptions): UseAuditLogResult;
 
 export declare interface UseAuditLogOptions {
@@ -26826,6 +27778,19 @@ export declare function useComponentDisplayClass(componentType: NiceComponentTyp
  */
 export declare function useComponentDisplayStyle(componentType: NiceComponentType, propStyle?: NiceDisplayStyle, primaryColor?: string): React.CSSProperties;
 
+/**
+ * Hook to get help content for a specific component
+ */
+export declare function useComponentHelp(componentName: string): {
+    content: HelpContent | null;
+    loading: boolean;
+    enabled: boolean;
+    loadContent: () => Promise<void>;
+    position: "tooltip" | "top" | "bottom" | "sidebar";
+    defaultExpanded: boolean;
+    showHelpIcon: boolean;
+};
+
 export declare function useContainerSize(ref: React.RefObject<HTMLElement | null>): UseContainerSizeResult;
 
 export declare interface UseContainerSizeResult {
@@ -26849,6 +27814,15 @@ ControlPreferences[T] | undefined,
 (updates: Partial<NonNullable<ControlPreferences[T]>>) => void
 ];
 
+/**
+ * Hook for cookie banner visibility.
+ */
+export declare function useCookieBannerVisibility(): {
+    shouldShow: boolean;
+    mode: TracelessMode;
+    dismiss: () => void;
+};
+
 /**
  * Hook for managing dark mode with system preference detection and persistence.
  * Automatically applies CSS classes to documentElement.
@@ -26949,6 +27923,29 @@ export declare interface UseDrawerResult {
     setOpen: (open: boolean) => void;
 }
 
+/**
+ * Hook for persisting editor state with Traceless policy awareness.
+ * Useful for NiceRichTextEditor, NiceCodeEditor, etc.
+ */
+export declare function useEditorStatePersistence({ storageKey, autoSaveInterval, maxVersions, }: {
+    storageKey: string;
+    autoSaveInterval?: number;
+    maxVersions?: number;
+}): {
+    draft: EditorPersistentState | null;
+    saveDraft: (content: string, cursorPosition?: {
+        line: number;
+        column: number;
+    }) => void;
+    saveToHistory: () => void;
+    restoreVersion: (version: number) => void;
+    clearDraft: () => void;
+    history: EditorPersistentState[];
+    hasDraft: boolean;
+    degraded: boolean;
+    policy: ITracelessPolicy;
+};
+
 export declare function useERPReportDesigner(): ERPReportDesignerContextValue;
 
 export declare function useFAQ(): FAQContextValue;
@@ -27053,6 +28050,30 @@ export declare interface UseGesturesReturn {
  */
 export declare function useGridPreferences(gridId: string): [GridPreferences | undefined, (prefs: GridPreferences | undefined) => void, (updates: Partial<GridPreferences>) => void];
 
+/**
+ * Hook for persisting grid state with Traceless policy awareness.
+ *
+ * @example
+ * ```tsx
+ * const { state, updateState, clearState, degraded } = useGridStatePersistence({
+ *   storageKey: 'my-grid',
+ *   initialState: { pageSize: 10 },
+ * });
+ *
+ * // Show warning if storage is degraded
+ * {degraded && <TracelessWarning useCase="grid-state" />}
+ * ```
+ */
+export declare function useGridStatePersistence({ storageKey, initialState, onStateChange, storageType, }: GridStatePersistenceOptions): {
+    state: GridPersistentState;
+    updateState: (partial: Partial<GridPersistentState>) => void;
+    setState: Dispatch<SetStateAction<GridPersistentState>>;
+    clearState: () => void;
+    degraded: boolean;
+    effectiveStorageType: "local" | "memory" | "session";
+    policy: ITracelessPolicy;
+};
+
 /**
  * Hook that returns a function to trigger haptic feedback.
  */
@@ -27415,6 +28436,11 @@ export declare function useNiceDisplayStyle(): NiceDisplayStyleContextValue;
 
 export declare function useNiceField<T = any>(source: NiceDataSource<T> | null | undefined, key: unknown, field: string): NiceFieldState;
 
+/**
+ * Hook to access global help configuration and utilities
+ */
+export declare function useNiceHelp(): HelpContextValue;
+
 /**
  * Hook that provides a `renderIcon` helper for resolving icon names or React nodes.
  * Used internally by components that accept `icon: string | ReactNode` props.
@@ -27549,6 +28575,15 @@ export declare interface UsePanResult {
     deltaY: number;
 }
 
+/**
+ * Hook for persisted state with graceful degradation.
+ * Falls back to in-memory state if storage not available.
+ */
+export declare function usePersistedState<T>(key: string, defaultValue: T, options?: {
+    namespace?: string;
+    storageMode?: 'local' | 'session';
+}): [T, (value: T | ((prev: T) => T)) => void, boolean];
+
 /**
  * Hook for detecting pinch-to-zoom gestures.
  */
@@ -27660,6 +28695,19 @@ export declare function useResolvedDisplayStyle(propStyle?: NiceDisplayStyle): {
     config: ThemeVariantConfig;
 };
 
+/**
+ * Resolve storage props against the current Traceless policy.
+ * Components can use this to determine what storage is actually available.
+ */
+export declare function useResolvedStorageProps(props: TracelessStorageProps): {
+    cookiesAllowed: boolean;
+    localStorageAllowed: boolean;
+    sessionStorageAllowed: boolean;
+    effectiveMode: TracelessMode;
+    canPersist: boolean;
+    degraded: boolean;
+};
+
 export declare function useResponsiveValue<T>(value: NiceResponsiveValue<T>, breakpoints?: NiceBreakpoints): T;
 
 /** Return focus to the element that was focused before the component mounted */
@@ -27955,6 +29003,20 @@ export declare interface UseSliderReturn {
     snap: (value: number) => number;
 }
 
+/**
+ * Hook to get a namespaced storage adapter.
+ */
+export declare function useStorageAdapter(namespace?: string): StorageAdapter;
+
+/**
+ * Hook for running compliance audit on mount.
+ */
+export declare function useStorageAudit(autoRun?: boolean): {
+    result: StorageAuditResult | null;
+    run: () => StorageAuditResult;
+    isCompliant: boolean | null;
+};
+
 export declare function useStreamDashboard(): StreamDashboardContextValue;
 
 /**
@@ -28087,6 +29149,80 @@ export declare function useTouchForm(): TouchFormContextType;
  */
 export declare function useTouchSlider(options: UseSliderOptions): UseSliderReturn;
 
+/**
+ * Drop-in replacement for localStorage that respects Traceless policy.
+ * Use this when migrating existing components that use localStorage directly.
+ *
+ * @example
+ * ```tsx
+ * // Before:
+ * const savedValue = localStorage.getItem('my-key');
+ * localStorage.setItem('my-key', value);
+ *
+ * // After:
+ * const { getItem, setItem } = useTracelessLocalStorage();
+ * const savedValue = getItem('my-key');
+ * setItem('my-key', value);
+ * ```
+ */
+export declare function useTracelessLocalStorage(): {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: () => void;
+    isAvailable: boolean;
+    effectiveMode: TracelessMode;
+    policy: ITracelessPolicy;
+};
+
+/**
+ * Hook to access the Traceless policy context.
+ * Throws if used outside TracelessProvider.
+ */
+export declare function useTracelessPolicy(): TracelessContextValue;
+
+/**
+ * Hook to access Traceless policy with fallback.
+ * Returns default policy if outside provider.
+ */
+export declare function useTracelessPolicySafe(): TracelessContextValue;
+
+/**
+ * Drop-in replacement for sessionStorage that respects Traceless policy.
+ */
+export declare function useTracelessSessionStorage(): {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: () => void;
+    isAvailable: boolean;
+    effectiveMode: TracelessMode;
+};
+
+/**
+ * Creates a storage object that mimics the Storage interface but respects
+ * Traceless policy. Use this for migrating existing code that expects a
+ * Storage-like object.
+ *
+ * @example
+ * ```tsx
+ * // In component
+ * const storage = useTracelessStorage();
+ *
+ * // Uses same interface as localStorage/sessionStorage
+ * storage.setItem('key', 'value');
+ * const val = storage.getItem('key');
+ * ```
+ */
+export declare function useTracelessStorage(preferredType?: 'local' | 'session'): {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    readonly length: number;
+    key(index: number): string | null;
+};
+
 export declare function useTranscoder(): TranscoderContextValue;
 
 export declare function useUndoKeyboard<T = unknown>(manager: NiceUndoManager<T>): void;
@@ -28818,6 +29954,28 @@ export declare function withPolling<T extends Record<string, any>>(source: NiceD
     setInterval(ms: number): void;
 };
 
+/**
+ * Adds Traceless storage props to a control registry entry.
+ * Use this when registering controls that can persist state.
+ *
+ * @example
+ * ```ts
+ * const myControl = withTracelessProps({
+ *   type: 'NiceDataGrid',
+ *   label: 'Data Grid',
+ *   category: 'Data',
+ *   propDescriptors: [...myProps],
+ *   defaultProps: { ...myDefaults },
+ * });
+ * ```
+ */
+export declare function withTracelessProps(entry: NiceControlRegistryEntry): NiceControlRegistryEntry;
+
+/**
+ * Adds Traceless storage props to all entries in a control registry array.
+ */
+export declare function withTracelessPropsAll(entries: NiceControlRegistryEntry[]): NiceControlRegistryEntry[];
+
 /**
  * HOC version of useWhyDidYouRender
  */