@nice2dev/ui 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -4,6 +4,8 @@ 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';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
@@ -11,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;
@@ -273,6 +276,24 @@ export declare interface AIStreamChunk {
     toolCalls?: AIToolCall[];
 }
 
+/**
+ * AI-generated match suggestion.
+ */
+export declare interface AISuggestion {
+    /** Statement item ID */
+    statementId: string;
+    /** Suggested entry IDs */
+    entryIds: string[];
+    /** Confidence score (0-100) */
+    confidence: number;
+    /** Confidence level */
+    confidenceLevel: MatchConfidence;
+    /** Explanation */
+    reason: string;
+    /** Factors that contributed to this suggestion */
+    factors: SuggestionFactor[];
+}
+
 /** AI generated tag */
 export declare interface AITag {
     id: string;
@@ -339,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
  */
@@ -590,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.
  */
@@ -650,6 +707,24 @@ export declare interface AutomationTrigger {
     config: Record<string, unknown>;
 }
 
+/**
+ * Axis configuration.
+ */
+declare interface AxisConfig {
+    /** Axis title */
+    title?: string;
+    /** Format function */
+    format?: (value: number | Date) => string;
+    /** Min value (auto if not set) */
+    min?: number;
+    /** Max value (auto if not set) */
+    max?: number;
+    /** Grid lines */
+    showGrid?: boolean;
+    /** Tick count hint */
+    tickCount?: number;
+}
+
 export declare type BackupCompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 
 export declare interface BackupDiff {
@@ -753,6 +828,42 @@ export declare type BadgeStyleVariant = 'solid' | 'soft' | 'outlined' | 'dot' |
  */
 export declare type BadgeVariant = 'dot' | 'count' | 'text';
 
+/**
+ * A single transaction from the bank statement import.
+ */
+export declare interface BankStatementItem {
+    /** Unique identifier */
+    id: string;
+    /** Transaction date */
+    date: Date | string;
+    /** Value date (settlement) */
+    valueDate?: Date | string;
+    /** Description / reference */
+    description: string;
+    /** Transaction amount (positive=credit, negative=debit) */
+    amount: number;
+    /** ISO currency code */
+    currency?: string;
+    /** Counterparty name */
+    counterparty?: string;
+    /** IBAN / account number */
+    counterpartyAccount?: string;
+    /** Bank reference number */
+    referenceNumber?: string;
+    /** End-to-end ID (SEPA) */
+    endToEndId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** Current reconciliation status */
+    status?: ReconciliationStatus;
+    /** Matched book entry IDs */
+    matchedEntryIds?: string[];
+    /** AI confidence (0-100) */
+    confidence?: number;
+    /** Excluded from reconciliation */
+    excluded?: boolean;
+}
+
 export declare interface BarcodeConfig {
     formats: ('ean13' | 'ean8' | 'code128' | 'code39' | 'qr' | 'datamatrix' | 'pdf417')[];
     autoFill?: {
@@ -815,6 +926,44 @@ export declare interface BlurAnnotation extends AnnotationBase {
     intensity: number;
 }
 
+/**
+ * A single entry from the accounting ledger / ERP.
+ */
+export declare interface BookEntry {
+    /** Unique identifier */
+    id: string;
+    /** Posting date */
+    date: Date | string;
+    /** Document date */
+    documentDate?: Date | string;
+    /** Description / posting text */
+    description: string;
+    /** Amount (positive=debit, negative=credit for bank account) */
+    amount: number;
+    /** ISO currency code */
+    currency?: string;
+    /** Document number (invoice, receipt, etc.) */
+    documentNumber?: string;
+    /** Customer/Vendor name */
+    partyName?: string;
+    /** Customer/Vendor ID */
+    partyId?: string;
+    /** Cost center */
+    costCenter?: string;
+    /** GL account */
+    glAccount?: string;
+    /** Tax code */
+    taxCode?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** Current reconciliation status */
+    status?: ReconciliationStatus;
+    /** Matched bank statement IDs */
+    matchedStatementIds?: string[];
+    /** AI confidence (0-100) */
+    confidence?: number;
+}
+
 /** Bounding box */
 export declare interface BoundingBox {
     x: number;
@@ -1279,6 +1428,26 @@ declare interface CannedResponse {
  */
 export declare type CardStyleVariant = 'flat' | 'elevated' | 'bordered' | 'glass' | 'gradient' | 'neumorphic' | 'outlined' | 'paper';
 
+/**
+ * Cash runway indicator configuration.
+ */
+declare interface CashRunwayConfig {
+    /** Enable cash runway indicator */
+    enabled?: boolean;
+    /** Threshold value (default: 0) - when forecast crosses this value */
+    threshold?: number;
+    /** Line color */
+    color?: string;
+    /** Label text */
+    label?: string;
+    /** Scenario ID to track (uses first visible scenario if not specified) */
+    scenarioId?: string;
+    /** Show label at top */
+    showLabel?: boolean;
+    /** Show exact date in label */
+    showDate?: boolean;
+}
+
 /** Cell position for keyboard navigation and selection. */
 declare interface CellPosition {
     rowKey: string;
@@ -1291,6 +1460,46 @@ declare interface CellRange {
     end: CellPosition;
 }
 
+/**
+ * Certification / standard definition.
+ */
+export declare interface Certification {
+    /** Unique ID */
+    id: string;
+    /** Certification name (e.g., "ISO 27001", "SOC 2", "GDPR") */
+    name: string;
+    /** Short code */
+    code?: string;
+    /** Description */
+    description?: string;
+    /** Icon or logo URL */
+    icon?: string;
+    /** Category */
+    category?: string;
+    /** Certification body */
+    issuingBody?: string;
+    /** Current status */
+    status: 'active' | 'expired' | 'pending' | 'not-certified';
+    /** Issue date */
+    issueDate?: Date | string;
+    /** Expiry date */
+    expiryDate?: Date | string;
+    /** Last audit date */
+    lastAuditDate?: Date | string;
+    /** Next audit date */
+    nextAuditDate?: Date | string;
+    /** Overall compliance percentage (0-100) */
+    complianceScore: number;
+    /** Requirements */
+    requirements: ComplianceRequirement[];
+    /** Risk score (0-100, higher = more risk) */
+    riskScore?: number;
+    /** RAG status */
+    ragStatus: RAGStatus;
+    /** Custom metadata */
+    metadata?: Record<string, any>;
+}
+
 export declare const CHART_COLORS: string[];
 
 export declare interface ChartDataPoint {
@@ -1368,6 +1577,36 @@ export declare function checkAriaCompliance(element: HTMLElement): string[];
  */
 export declare function checkContrastAAA(foreground: string, background: string, isLargeText?: boolean): WCAGCheckResult;
 
+/**
+ * Checklist item for compliance tasks.
+ */
+declare interface ChecklistItem {
+    /** Unique ID */
+    id: string;
+    /** Item text */
+    text: string;
+    /** Is checked */
+    checked: boolean;
+    /** Category / group */
+    category?: string;
+    /** Related certification ID */
+    certificationId?: string;
+    /** Related requirement ID */
+    requirementId?: string;
+    /** Priority */
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+    /** Due date */
+    dueDate?: Date | string;
+    /** Assignee */
+    assignee?: string;
+    /** Notes */
+    notes?: string;
+    /** Created date */
+    createdAt?: Date | string;
+    /** Completed date */
+    completedAt?: Date | string;
+}
+
 /** Run health checks on all modules in the app manifest. */
 export declare function checkModuleHealth(appManifest: NiceAppManifest): NiceHealthReport;
 
@@ -1726,6 +1965,252 @@ export declare function compareSemver(a: SemVer, b: SemVer): -1 | 0 | 1;
 
 export declare type ComparisonOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEquals' | 'lessThan' | 'lessThanOrEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'isNull' | 'isNotNull' | 'matches' | 'between';
 
+/**
+ * Custom labels for localization.
+ */
+export declare interface ComplianceDashboardLabels {
+    overview?: string;
+    requirements?: string;
+    timeline?: string;
+    gaps?: string;
+    evidence?: string;
+    checklist?: string;
+    overlap?: string;
+    costs?: string;
+    compliant?: string;
+    nonCompliant?: string;
+    inProgress?: string;
+    notStarted?: string;
+    deferred?: string;
+    notApplicable?: string;
+    search?: string;
+    filter?: string;
+    export?: string;
+    uploadEvidence?: string;
+    viewDetails?: string;
+    dueDate?: string;
+    lastReview?: string;
+    owner?: string;
+    priority?: string;
+    noData?: string;
+    overdue?: string;
+    upcoming?: string;
+    checklistCompleted?: string;
+    checklistPending?: string;
+    addChecklistItem?: string;
+    sharedControls?: string;
+    uniqueControls?: string;
+    selectCertifications?: string;
+    overlapAnalysis?: string;
+    plannedBudget?: string;
+    actualSpend?: string;
+    variance?: string;
+    budgetOverview?: string;
+    byCategory?: string;
+    byCertification?: string;
+    consulting?: string;
+    software?: string;
+    training?: string;
+    audit?: string;
+    personnel?: string;
+    infrastructure?: string;
+    other?: string;
+    underBudget?: string;
+    overBudget?: string;
+    onTrack?: string;
+}
+
+/**
+ * Imperative handle.
+ */
+export declare interface ComplianceDashboardRef {
+    /** Get current filter */
+    getFilter(): ComplianceFilter;
+    /** Set filter */
+    setFilter(filter: ComplianceFilter): void;
+    /** Get current view */
+    getView(): DashboardView;
+    /** Set view */
+    setView(view: DashboardView): void;
+    /** Export data */
+    export(format: 'pdf' | 'xlsx' | 'csv'): void;
+    /** Get overall compliance score */
+    getOverallScore(): number;
+    /** Get gaps */
+    getGaps(): GapItem[];
+    /** Refresh data */
+    refresh(): void;
+}
+
+/**
+ * Timeline event.
+ */
+export declare interface ComplianceEvent {
+    /** Unique ID */
+    id: string;
+    /** Event type */
+    type: 'audit' | 'certification' | 'review' | 'update' | 'incident' | 'remediation' | 'training';
+    /** Title */
+    title: string;
+    /** Description */
+    description?: string;
+    /** Date */
+    date: Date | string;
+    /** Related certification ID */
+    certificationId?: string;
+    /** Related requirement ID */
+    requirementId?: string;
+    /** User who performed action */
+    user?: string;
+    /** Status */
+    status?: 'completed' | 'scheduled' | 'overdue' | 'cancelled';
+}
+
+/**
+ * Filter options.
+ */
+export declare interface ComplianceFilter {
+    /** Certification IDs */
+    certifications?: string[];
+    /** Requirement statuses */
+    statuses?: RequirementStatus[];
+    /** RAG statuses */
+    ragStatuses?: RAGStatus[];
+    /** Categories */
+    categories?: string[];
+    /** Search text */
+    search?: string;
+    /** Show only overdue */
+    overdueOnly?: boolean;
+}
+
+/**
+ * Individual compliance requirement / control.
+ */
+export declare interface ComplianceRequirement {
+    /** Unique ID */
+    id: string;
+    /** Requirement code (e.g., "A.5.1.1") */
+    code: string;
+    /** Title */
+    title: string;
+    /** Description */
+    description?: string;
+    /** Category / domain */
+    category?: string;
+    /** Section */
+    section?: string;
+    /** Current status */
+    status: RequirementStatus;
+    /** Compliance level (0-100) */
+    complianceLevel: number;
+    /** Owner / responsible person */
+    owner?: string;
+    /** Due date */
+    dueDate?: Date | string;
+    /** Last review date */
+    lastReviewDate?: Date | string;
+    /** Evidence items */
+    evidence?: EvidenceItem[];
+    /** Gap description (if non-compliant) */
+    gap?: string;
+    /** Remediation plan */
+    remediationPlan?: string;
+    /** Priority */
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+    /** Risk score */
+    riskScore?: number;
+    /** Notes */
+    notes?: string;
+}
+
+/**
+ * Complete component documentation
+ */
+export declare interface ComponentDoc {
+    /** Schema version for future compatibility */
+    $schema?: string;
+    /** Component name (e.g., "NiceButton") */
+    name: string;
+    /** Display name for docs */
+    displayName?: string;
+    /** Package this component belongs to */
+    package: string;
+    /** Category for grouping (e.g., "buttons", "inputs", "navigation") */
+    category: string;
+    /** Sub-category for finer grouping */
+    subcategory?: string;
+    /** Brief one-line description */
+    summary: string;
+    /** Full description with markdown support */
+    description: string;
+    /** Version when this component was added */
+    since?: string;
+    /** Current status */
+    status?: 'stable' | 'beta' | 'experimental' | 'deprecated';
+    /** Deprecation notice if applicable */
+    deprecationNotice?: string;
+    /** Import statement */
+    import: {
+        /** Named exports */
+        named: string[];
+        /** Package to import from */
+        from: string;
+        /** Type imports if needed separately */
+        types?: string[];
+    };
+    /** Component props */
+    props: DocProp[];
+    /** Events/callbacks */
+    events?: DocEvent[];
+    /** Slots/render props */
+    slots?: DocSlot[];
+    /** Methods exposed via ref or hook */
+    methods?: DocMethod[];
+    /** Theming information */
+    theming?: {
+        /** How this component integrates with NiceThemeProvider */
+        description?: string;
+        /** CSS variables used */
+        cssVariables?: DocCssVariable[];
+        /** CSS class names for customization */
+        cssClasses?: Array<{
+            name: string;
+            description: string;
+        }>;
+        /** Example theme customization */
+        example?: string;
+    };
+    /** i18n information */
+    i18n?: {
+        /** How this component integrates with NiceI18nProvider */
+        description?: string;
+        /** Translation keys used */
+        keys?: DocI18nKey[];
+        /** Example i18n setup */
+        example?: string;
+    };
+    /** Accessibility information */
+    accessibility?: DocAccessibility;
+    /** Usage examples */
+    examples: DocExample[];
+    /** Best practices and tips */
+    bestPractices?: string[];
+    /** Common pitfalls to avoid */
+    pitfalls?: string[];
+    /** Related components and patterns */
+    related?: DocRelated[];
+    /** See also links */
+    seeAlso?: Array<{
+        title: string;
+        url: string;
+    }>;
+    /** Tags for search */
+    tags?: string[];
+    /** Last updated timestamp */
+    lastUpdated?: string;
+}
+
 export declare interface ComponentMeta {
     name: string;
     tag: string;
@@ -1767,6 +2252,18 @@ export declare interface ConditionNode extends WorkflowNodeBase {
  */
 export declare type ConditionType = 'if' | 'switch' | 'filter' | 'router';
 
+/**
+ * Confidence band configuration.
+ */
+export declare interface ConfidenceBandConfig {
+    /** Confidence level (e.g., 80, 95) */
+    level: number;
+    /** Fill color */
+    color?: string;
+    /** Fill opacity (0-1) */
+    opacity?: number;
+}
+
 /**
  * Node configuration schema (for dynamic forms)
  */
@@ -1996,6 +2493,41 @@ export declare interface ControlPreferences {
  */
 export declare type ControlType = 'start' | 'end' | 'error-handler' | 'retry' | 'merge' | 'split';
 
+/**
+ * Cost category for budget tracking.
+ */
+declare type CostCategory = 'consulting' | 'software' | 'training' | 'audit' | 'personnel' | 'infrastructure' | 'other';
+
+/**
+ * Cost item for certification budget tracking.
+ */
+declare interface CostItem {
+    /** Unique ID */
+    id: string;
+    /** Cost description */
+    description: string;
+    /** Related certification ID */
+    certificationId: string;
+    /** Category */
+    category: CostCategory;
+    /** Planned amount */
+    plannedAmount: number;
+    /** Actual amount spent */
+    actualAmount: number;
+    /** Currency */
+    currency?: string;
+    /** Date incurred */
+    date?: Date | string;
+    /** Vendor / supplier */
+    vendor?: string;
+    /** Invoice reference */
+    invoiceRef?: string;
+    /** Notes */
+    notes?: string;
+    /** Status */
+    status?: 'planned' | 'committed' | 'paid' | 'overrun';
+}
+
 export declare const COUNTRIES: Country[];
 
 export declare interface Country {
@@ -2022,6 +2554,12 @@ export declare function createCustomDataSource<T extends Record<string, any> = a
 
 export declare function createDefaultWorkflow(): WorkflowSchema;
 
+/**
+ * Create a documentation index from an array of component docs.
+ * Useful for building navigation and search.
+ */
+export declare function createDocIndex(docs: ComponentDoc[], packageName: string): DocIndex;
+
 export declare function createGraphQLDataSource<T extends Record<string, any> = any>(config: NiceGraphQLConfig<T>): NiceDataSource<T>;
 
 export declare function createGraphQLSubscriptionSource<T>(config: GraphQLSubscriptionConfig<T>): GraphQLSubscriptionSource<T>;
@@ -2291,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;
@@ -2394,6 +2950,11 @@ declare interface DashboardTheme {
     accentColor?: string;
 }
 
+/**
+ * Dashboard view mode.
+ */
+export declare type DashboardView = 'overview' | 'requirements' | 'timeline' | 'gaps' | 'evidence' | 'checklist' | 'overlap' | 'costs';
+
 /**
  * Widget definition
  */
@@ -2847,69 +3408,245 @@ export declare interface DMSSearchFilter {
     metadata?: Record<string, unknown>;
 }
 
-declare interface Document_2 {
-    id: string;
-    type: DocumentType_2;
-    status: DocumentStatus;
-    name: string;
-    extension: string;
-    folderId?: string;
-    folderPath?: string;
-    metadata: DocumentMetadata;
-    versions: DMSDocumentVersion[];
-    currentVersion: DMSDocumentVersion;
-    permissions: DocumentPermission[];
-    activeWorkflows?: DocumentWorkflow[];
-    createdAt: string;
-    createdBy: string;
-    updatedAt: string;
-    updatedBy: string;
-    linkedDocuments?: string[];
-    relatedEntities?: {
-        type: string;
-        id: string;
-        name?: string;
-    }[];
-    searchContent?: string;
-    searchHighlights?: string[];
+/**
+ * Accessibility information
+ */
+export declare interface DocAccessibility {
+    /** ARIA role used */
+    role?: string;
+    /** Keyboard interactions */
+    keyboard?: Array<{
+        key: string;
+        action: string;
+    }>;
+    /** Screen reader considerations */
+    screenReader?: string;
+    /** WCAG compliance notes */
+    wcag?: string;
 }
-export { Document_2 as Document }
 
-export declare interface DocumentMetadata {
-    title?: string;
-    description?: string;
-    author?: string;
-    keywords?: string[];
-    category?: string;
-    department?: string;
-    confidentiality?: 'public' | 'internal' | 'confidential' | 'secret';
-    expiryDate?: string;
-    retentionPolicy?: string;
-    language?: string;
-    ocrText?: string;
-    ocrLanguage?: string;
-    ocrConfidence?: number;
-    custom?: Record<string, unknown>;
+/**
+ * CSS variable that the component uses for theming
+ */
+export declare interface DocCssVariable {
+    /** CSS variable name (e.g., "--bg-primary") */
+    name: string;
+    /** What this variable controls */
+    description: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Which part of the component this affects */
+    affectedArea?: string;
 }
 
-export declare interface DocumentPermission {
-    principalType: 'user' | 'group' | 'role';
-    principalId: string;
-    principalName?: string;
-    level: PermissionLevel;
-    inherited?: boolean;
+/**
+ * Event/callback definition
+ */
+export declare interface DocEvent {
+    /** Event name (e.g., "onChange", "onComplete") */
+    name: string;
+    /** Event handler signature */
+    signature: string;
+    /** Description of when this event fires */
+    description: string;
+    /** Parameters passed to the handler */
+    parameters?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }>;
 }
 
-export declare interface DocumentSignature {
-    id: string;
-    signedAt: string;
-    signedBy: string;
-    signedByName?: string;
-    signatureType: 'electronic' | 'digital' | 'qualified';
-    certificate?: string;
-    reason?: string;
-    location?: string;
-    valid?: boolean;
+/**
+ * Code example with description
+ */
+export declare interface DocExample {
+    /** Example title */
+    title: string;
+    /** What this example demonstrates */
+    description: string;
+    /** The actual code */
+    code: string;
+    /** Language for syntax highlighting */
+    language?: 'tsx' | 'jsx' | 'typescript' | 'javascript' | 'css';
+    /** Whether this example should show a live preview */
+    preview?: boolean;
+    /** Initial prop values for live preview */
+    previewProps?: Record<string, unknown>;
+}
+
+/**
+ * i18n key that the component uses
+ */
+export declare interface DocI18nKey {
+    /** Translation key path */
+    key: string;
+    /** English default text */
+    defaultText: string;
+    /** Where this text appears in the component */
+    context: string;
+    /** Placeholders in the text (e.g., "{count}") */
+    placeholders?: string[];
+}
+
+/**
+ * Documentation index for a package
+ */
+export declare interface DocIndex {
+    /** Package name */
+    package: string;
+    /** All documented components */
+    components: Array<{
+        name: string;
+        category: string;
+        summary: string;
+        status?: 'stable' | 'beta' | 'experimental' | 'deprecated';
+    }>;
+    /** Last generated timestamp */
+    generated: string;
+}
+
+/**
+ * Method exposed via ref or hook
+ */
+export declare interface DocMethod {
+    /** Method name */
+    name: string;
+    /** Method signature */
+    signature: string;
+    /** Description of what this method does */
+    description: string;
+    /** Return value description */
+    returns?: string;
+}
+
+/**
+ * NiceToDev Component Documentation Schema
+ *
+ * Standardized JSON documentation format for all controls.
+ * Used by AI agents and NiceDocumentationViewer for interactive docs.
+ */
+/**
+ * Prop definition for component documentation
+ */
+export declare interface DocProp {
+    /** Property name */
+    name: string;
+    /** TypeScript type (e.g., "string", "boolean", "() => void") */
+    type: string;
+    /** Whether the prop is required */
+    required?: boolean;
+    /** Default value if any */
+    defaultValue?: string;
+    /** Description of what this prop does */
+    description: string;
+    /** Possible values for union types or enums */
+    options?: Array<{
+        value: string;
+        label: string;
+        description?: string;
+    }>;
+    /** Related props that work together with this one */
+    relatedProps?: string[];
+    /** Minimum API version where this prop is available */
+    since?: string;
+    /** If deprecated, explain why and what to use instead */
+    deprecated?: string;
+}
+
+/**
+ * Related component or pattern
+ */
+export declare interface DocRelated {
+    /** Component or pattern name */
+    name: string;
+    /** Package it's from */
+    package: string;
+    /** Brief description of relationship */
+    relationship: string;
+}
+
+/**
+ * Slot/render prop definition
+ */
+export declare interface DocSlot {
+    /** Slot name */
+    name: string;
+    /** Description of what this slot is for */
+    description: string;
+    /** Props passed to the render function */
+    props?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }>;
+}
+
+declare type DocTab = 'overview' | 'props' | 'events' | 'theming' | 'i18n' | 'examples' | 'accessibility' | 'api';
+
+declare interface Document_2 {
+    id: string;
+    type: DocumentType_2;
+    status: DocumentStatus;
+    name: string;
+    extension: string;
+    folderId?: string;
+    folderPath?: string;
+    metadata: DocumentMetadata;
+    versions: DMSDocumentVersion[];
+    currentVersion: DMSDocumentVersion;
+    permissions: DocumentPermission[];
+    activeWorkflows?: DocumentWorkflow[];
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    linkedDocuments?: string[];
+    relatedEntities?: {
+        type: string;
+        id: string;
+        name?: string;
+    }[];
+    searchContent?: string;
+    searchHighlights?: string[];
+}
+export { Document_2 as Document }
+
+export declare interface DocumentMetadata {
+    title?: string;
+    description?: string;
+    author?: string;
+    keywords?: string[];
+    category?: string;
+    department?: string;
+    confidentiality?: 'public' | 'internal' | 'confidential' | 'secret';
+    expiryDate?: string;
+    retentionPolicy?: string;
+    language?: string;
+    ocrText?: string;
+    ocrLanguage?: string;
+    ocrConfidence?: number;
+    custom?: Record<string, unknown>;
+}
+
+export declare interface DocumentPermission {
+    principalType: 'user' | 'group' | 'role';
+    principalId: string;
+    principalName?: string;
+    level: PermissionLevel;
+    inherited?: boolean;
+}
+
+export declare interface DocumentSignature {
+    id: string;
+    signedAt: string;
+    signedBy: string;
+    signedByName?: string;
+    signatureType: 'electronic' | 'digital' | 'qualified';
+    certificate?: string;
+    reason?: string;
+    location?: string;
+    valid?: boolean;
 }
 
 export declare type DocumentStatus = 'draft' | 'pending_review' | 'approved' | 'rejected' | 'published' | 'archived' | 'deleted';
@@ -3068,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';
 }
@@ -3500,6 +4254,32 @@ declare interface ESLintRuleContext {
     };
 }
 
+/**
+ * Evidence item for a requirement.
+ */
+export declare interface EvidenceItem {
+    /** Unique ID */
+    id: string;
+    /** File name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** File type */
+    type: 'document' | 'screenshot' | 'log' | 'report' | 'policy' | 'other';
+    /** URL or file path */
+    url?: string;
+    /** Upload date */
+    uploadDate: Date | string;
+    /** Uploaded by */
+    uploadedBy?: string;
+    /** Valid until */
+    validUntil?: Date | string;
+    /** File size in bytes */
+    size?: number;
+    /** Status */
+    status: 'pending' | 'approved' | 'rejected' | 'expired';
+}
+
 export declare type ExportFormat = 'mp4' | 'webm' | 'gif' | 'mov' | 'avi';
 
 export declare interface ExportProgress {
@@ -3574,6 +4354,11 @@ export declare interface ExpressionSet {
 /** Extract all control types used in a view. */
 export declare function extractControlTypes(view: NiceViewDefinitionV2): string[];
 
+/**
+ * Extract all CSS variables from a doc
+ */
+export declare function extractCssVariables(doc: ComponentDoc): string[];
+
 /** Extracted frame */
 export declare interface ExtractedFrame {
     id: string;
@@ -3583,6 +4368,11 @@ export declare interface ExtractedFrame {
     annotations?: string[];
 }
 
+/**
+ * Extract all i18n keys from a doc
+ */
+export declare function extractI18nKeys(doc: ComponentDoc): string[];
+
 /**
  * Extract tokens from NiceTheme
  */
@@ -3819,6 +4609,104 @@ export declare interface Folder {
  */
 export declare function forceGC(): void;
 
+/**
+ * Annotation marker on the chart.
+ */
+export declare interface ForecastAnnotation {
+    /** Unique ID */
+    id: string;
+    /** Date position */
+    date: Date | string | number;
+    /** Annotation type */
+    type: 'event' | 'anomaly' | 'note' | 'milestone' | 'custom';
+    /** Label text */
+    label: string;
+    /** Description (shown in tooltip) */
+    description?: string;
+    /** Icon or emoji */
+    icon?: string;
+    /** Color */
+    color?: string;
+    /** Show vertical line */
+    showLine?: boolean;
+}
+
+/**
+ * Custom labels for localization.
+ */
+export declare interface ForecastChartLabels {
+    actual?: string;
+    forecast?: string;
+    confidence?: string;
+    annotations?: string;
+    noData?: string;
+    zoomIn?: string;
+    zoomOut?: string;
+    resetZoom?: string;
+    export?: string;
+    cashRunsOut?: string;
+}
+
+/**
+ * Imperative handle for NiceForecastChart.
+ */
+export declare interface ForecastChartRef {
+    /** Get current scenarios */
+    getScenarios(): ForecastScenario[];
+    /** Update scenario data */
+    updateScenario(id: string, data: ForecastDataPoint[]): void;
+    /** Toggle scenario visibility */
+    toggleScenario(id: string): void;
+    /** Set zoom range */
+    setZoomRange(startDate: Date, endDate: Date): void;
+    /** Reset zoom */
+    resetZoom(): void;
+    /** Export as image */
+    exportImage(format: 'png' | 'svg'): string | null;
+    /** Get data at date */
+    getDataAtDate(date: Date): TooltipData | null;
+}
+
+/**
+ * Single data point in time series.
+ */
+export declare interface ForecastDataPoint {
+    /** Date or timestamp */
+    date: Date | string | number;
+    /** Actual/historical value */
+    value?: number;
+    /** Forecast value (if in forecast period) */
+    forecast?: number;
+    /** Lower confidence bound */
+    lowerBound?: number;
+    /** Upper confidence bound */
+    upperBound?: number;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * A forecast scenario for comparison.
+ */
+export declare interface ForecastScenario {
+    /** Unique ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Data points */
+    data: ForecastDataPoint[];
+    /** Line color */
+    color?: string;
+    /** Is this the base/main scenario */
+    isBase?: boolean;
+    /** Confidence interval percentage (e.g., 95) */
+    confidenceLevel?: number;
+    /** Show confidence band */
+    showConfidenceBand?: boolean;
+    /** Visible */
+    visible?: boolean;
+}
+
 declare function formatColor(hsl: HSLColor, format: ColorFormat): string;
 
 /** Format a diff result as a human-readable string. */
@@ -4166,6 +5054,34 @@ export declare interface FuzzyMatch {
 
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch | null;
 
+/**
+ * Gap analysis item.
+ */
+export declare interface GapItem {
+    /** Requirement ID */
+    requirementId: string;
+    /** Requirement code */
+    code: string;
+    /** Requirement title */
+    title: string;
+    /** Current state */
+    currentState: string;
+    /** Target state */
+    targetState: string;
+    /** Gap description */
+    gap: string;
+    /** Remediation steps */
+    remediation: string;
+    /** Effort estimate */
+    effort?: 'low' | 'medium' | 'high';
+    /** Priority */
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    /** Due date */
+    dueDate?: Date | string;
+    /** Status */
+    status: RequirementStatus;
+}
+
 export declare type GaugeType = 'temperature' | 'humidity' | 'lux' | 'co2' | 'pm25';
 
 /** Generate adapter wrappers for all components from source → target framework */
@@ -4225,6 +5141,11 @@ export declare function generateHarmony(baseHue: number, mode: NiceHarmonyMode,
  */
 export declare function generateInputStyles(variant: InputStyleVariant): Record<string, string>;
 
+/**
+ * Generate a TypeScript interface from props
+ */
+export declare function generateInterface(doc: ComponentDoc): string;
+
 /**
  * Generate Mermaid diagram syntax from schema
  */
@@ -4299,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;
 
@@ -4427,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;
@@ -4622,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
  */
@@ -4644,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.
  */
@@ -4681,6 +5640,15 @@ export declare interface GroupedResult<T> {
     groups?: GroupedResult<T>[];
 }
 
+/**
+ * Group props by category (required, optional, events, deprecated)
+ */
+export declare function groupProps(props: DocProp[]): {
+    required: DocProp[];
+    optional: DocProp[];
+    deprecated: DocProp[];
+};
+
 /**
  * Predefined haptic patterns
  */
@@ -4789,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;
@@ -4880,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
  */
@@ -5175,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';
 
@@ -5445,6 +6502,18 @@ export declare type LeakSeverity = 'info' | 'warning' | 'critical';
  */
 export declare type LeakType = 'setState-after-unmount' | 'timer-not-cleared' | 'listener-not-removed' | 'subscription-not-unsubscribed' | 'websocket-not-closed' | 'abort-controller-not-aborted' | 'large-closure' | 'component-retained' | 'detached-dom-node';
 
+/**
+ * Legend configuration.
+ */
+declare interface LegendConfig {
+    /** Show legend */
+    enabled?: boolean;
+    /** Position */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Interactive (click to toggle) */
+    interactive?: boolean;
+}
+
 /** License information */
 export declare interface LicenseInfo {
     type: LicenseType;
@@ -5529,7 +6598,146 @@ export declare interface LiveRegionOptions {
 }
 
 /**
- * LocalStorage adapter
+ * Load a component documentation file dynamically.
+ * Works with bundlers that support JSON imports.
+ *
+ * @example
+ * const doc = await loadComponentDoc('NiceButton');
+ */
+export declare function loadComponentDoc(componentName: string): Promise<ComponentDoc | null>;
+
+/**
+ * Custom labels for localization.
+ */
+export declare interface LoanCalculatorLabels {
+    title?: string;
+    principal?: string;
+    interestRate?: string;
+    term?: string;
+    monthlyPayment?: string;
+    totalPayment?: string;
+    totalInterest?: string;
+    schedule?: string;
+    comparison?: string;
+    addScenario?: string;
+    removeScenario?: string;
+    export?: string;
+    exportPDF?: string;
+    exportCSV?: string;
+    exportXLSX?: string;
+    months?: string;
+    years?: string;
+    paymentNumber?: string;
+    paymentDate?: string;
+    principalPortion?: string;
+    interestPortion?: string;
+    balance?: string;
+    annuity?: string;
+    linear?: string;
+    bullet?: string;
+}
+
+/**
+ * Imperative handle for NiceLoanCalculator.
+ */
+export declare interface LoanCalculatorRef {
+    /** Get current parameters */
+    getParams(): LoanParameters;
+    /** Set parameters */
+    setParams(params: Partial<LoanParameters>): void;
+    /** Get calculation result */
+    getResult(): LoanResult | null;
+    /** Recalculate */
+    calculate(): LoanResult;
+    /** Add comparison scenario */
+    addScenario(scenario: Omit<LoanScenario, 'result'>): void;
+    /** Remove scenario */
+    removeScenario(id: string): void;
+    /** Get all scenarios */
+    getScenarios(): LoanScenario[];
+    /** Export data */
+    export(format: 'csv' | 'pdf' | 'xlsx'): void;
+    /** Reset to defaults */
+    reset(): void;
+}
+
+/**
+ * Loan parameters input.
+ */
+export declare interface LoanParameters {
+    /** Loan principal amount */
+    principal: number;
+    /** Annual interest rate (as percentage, e.g. 5.5 for 5.5%) */
+    annualRate: number;
+    /** Loan term in months */
+    termMonths: number;
+    /** Loan type */
+    type?: LoanType;
+    /** Payment frequency */
+    frequency?: PaymentFrequency;
+    /** Start date */
+    startDate?: Date | string;
+    /** Grace period in months */
+    gracePeriod?: number;
+    /** Extra monthly payment */
+    extraPayment?: number;
+    /** One-time fees (origination, etc.) */
+    fees?: number;
+    /** Insurance (monthly) */
+    insurance?: number;
+}
+
+/**
+ * Loan calculation result.
+ */
+export declare interface LoanResult {
+    /** Monthly payment amount */
+    monthlyPayment: number;
+    /** Total payment over loan term */
+    totalPayment: number;
+    /** Total interest paid */
+    totalInterest: number;
+    /** Total fees */
+    totalFees: number;
+    /** Total insurance */
+    totalInsurance: number;
+    /** Effective annual rate (APR) */
+    effectiveRate: number;
+    /** Payment schedule */
+    schedule: PaymentScheduleItem[];
+    /** Principal amount */
+    principal: number;
+    /** Loan term in months */
+    termMonths: number;
+    /** Actual term (may be shorter with extra payments) */
+    actualTermMonths: number;
+    /** Interest savings from extra payments */
+    interestSavings: number;
+}
+
+/**
+ * Comparison scenario.
+ */
+export declare interface LoanScenario {
+    /** Scenario ID */
+    id: string;
+    /** Scenario name */
+    name: string;
+    /** Loan parameters */
+    params: LoanParameters;
+    /** Calculated result */
+    result?: LoanResult;
+    /** Color for charts */
+    color?: string;
+}
+
+/**
+ * Loan type / repayment method.
+ */
+export declare type LoanType = 'annuity' | 'linear' | 'bullet' | 'custom';
+
+/**
+ * LocalStorage adapter
  */
 export declare class LocalStorageAdapter implements PreferencesStorageAdapter {
     private key;
@@ -5732,9 +6940,50 @@ export declare interface MapRegion {
 /** Marker category */
 export declare type MarkerCategory = 'note' | 'issue' | 'question' | 'chapter' | 'highlight' | 'action' | 'custom';
 
+/**
+ * Match confidence level.
+ */
+declare type MatchConfidence = 'high' | 'medium' | 'low';
+
+/**
+ * Single matching criterion.
+ */
+declare interface MatchCriteria {
+    /** Field to compare on statement */
+    statementField: keyof BankStatementItem | string;
+    /** Field to compare on entry */
+    entryField: keyof BookEntry | string;
+    /** Comparison type */
+    comparison: 'exact' | 'contains' | 'startsWith' | 'regex' | 'fuzzy' | 'amount';
+    /** Tolerance for amount comparison (as decimal, e.g., 0.01 for 1%) */
+    tolerance?: number;
+    /** Transform function name */
+    transform?: 'lowercase' | 'uppercase' | 'trim' | 'removeSpaces' | 'digits';
+}
+
 /** Check if a keyboard event matches a shortcut */
 export declare function matchesShortcut(e: default_2.KeyboardEvent | KeyboardEvent, shortcut: KeyboardShortcut): boolean;
 
+/**
+ * Rule-based matching configuration.
+ */
+export declare interface MatchingRule {
+    /** Rule ID */
+    id: string;
+    /** Rule name */
+    name: string;
+    /** Priority (higher = first) */
+    priority: number;
+    /** Is rule active */
+    enabled: boolean;
+    /** Match criteria */
+    criteria: MatchCriteria[];
+    /** Required criteria count to match (default: all) */
+    minCriteriaCount?: number;
+    /** Description */
+    description?: string;
+}
+
 /**
  * Material Design app bar
  */
@@ -5901,11 +7150,555 @@ export declare interface MockLiveChartSourceConfig {
  */
 export declare type ModalStyleVariant = 'default' | 'centered' | 'fullscreen' | 'sheet' | 'glass' | 'drawer';
 
+/** Audit info display config. */
+declare interface ModuleAuditConfig {
+    showCreatedBy?: boolean;
+    showCreatedAt?: boolean;
+    showModifiedBy?: boolean;
+    showModifiedAt?: boolean;
+    dateFormat?: string;
+    showUserAvatar?: boolean;
+}
+
+/** Supported cell renderer types for NiceModuleGrid. */
+declare type ModuleCellRendererType = 'text' | 'number' | 'currency' | 'date' | 'datetime' | 'boolean' | 'enum' | 'link' | 'image' | 'progress' | 'rating' | 'color' | 'badge' | 'avatar' | 'percent' | 'custom';
+
+/** Condition group with AND/OR logic. */
+declare interface ModuleConditionGroup {
+    logic: 'and' | 'or';
+    conditions: (ModuleFieldCondition | ModuleConditionGroup)[];
+}
+
+/** Operator for conditional field visibility/requirement. */
+declare type ModuleConditionOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'greaterThan' | 'lessThan' | 'greaterOrEqual' | 'lessOrEqual' | 'isEmpty' | 'isNotEmpty' | 'matches' | 'in' | 'notIn';
+
+/** Context menu action. */
+declare interface ModuleContextMenuItem<T = any> {
+    key: string;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean | ((row: T) => boolean);
+    hidden?: boolean | ((row: T) => boolean);
+    danger?: boolean;
+    divider?: boolean;
+    permission?: string;
+    onClick?: (row: T) => void;
+}
+
+/** Draft auto-save configuration. */
+declare interface ModuleDraftConfig {
+    enabled: boolean;
+    /** Auto-save interval in ms */
+    interval?: number;
+    /** Storage key prefix */
+    storageKey?: string;
+    /** Max drafts to keep */
+    maxDrafts?: number;
+    /** Restore prompt on load */
+    restorePrompt?: boolean;
+}
+
+/** Empty state configuration. */
+declare interface ModuleEmptyState {
+    icon?: React.ReactNode;
+    title: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+        icon?: React.ReactNode;
+    };
+}
+
+/**
+ * Module entity field definition from JSON schema.
+ * Used by OmniVerk ERP backend to define 527+ entity forms.
+ */
+export declare interface ModuleEntityField {
+    /** Unique field identifier */
+    id: string;
+    /** Field name (used as form value key) */
+    name: string;
+    /** Field type */
+    type: ModuleFieldType;
+    /** Display label (i18n key or literal) */
+    label: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text below field */
+    helpText?: string;
+    /** Tooltip on hover */
+    tooltip?: string;
+    /** Prefix content (icon or text) */
+    prefix?: React.ReactNode | string;
+    /** Suffix content (icon or text) */
+    suffix?: React.ReactNode | string;
+    /** Required field */
+    required?: boolean;
+    /** Validation rules */
+    validations?: ModuleFieldValidation[];
+    /** Conditional requirement */
+    requiredIf?: ModuleConditionGroup | ModuleFieldCondition;
+    /** Read-only field */
+    readOnly?: boolean;
+    /** Disabled field */
+    disabled?: boolean;
+    /** Conditional visibility */
+    visibleIf?: ModuleConditionGroup | ModuleFieldCondition;
+    /** Conditional disabled state */
+    disabledIf?: ModuleConditionGroup | ModuleFieldCondition;
+    /** Default value */
+    defaultValue?: any;
+    /** Dynamic default (expression or function name) */
+    defaultExpression?: string;
+    /** Grid layout */
+    layout?: ModuleFieldLayout;
+    /** Section/group name */
+    section?: string;
+    /** Tab name (for tabbed forms) */
+    tab?: string;
+    /** Sort order within section */
+    order?: number;
+    /** Static options for select/radio */
+    options?: ModuleFieldOption[];
+    /** Async options loader */
+    optionsLoader?: ModuleFieldOptionsLoader;
+    /** Number config */
+    numberConfig?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        precision?: number;
+        format?: string;
+    };
+    /** Currency config */
+    currencyConfig?: {
+        code?: string;
+        precision?: number;
+        allowNegative?: boolean;
+    };
+    /** Date config */
+    dateConfig?: {
+        format?: string;
+        minDate?: string | Date;
+        maxDate?: string | Date;
+        disabledDates?: (string | Date)[];
+        showTime?: boolean;
+    };
+    /** Text config */
+    textConfig?: {
+        minLength?: number;
+        maxLength?: number;
+        multiline?: boolean;
+        rows?: number;
+        autoResize?: boolean;
+        showCharCount?: boolean;
+    };
+    /** Lookup/relation config */
+    lookupConfig?: ModuleLookupConfig;
+    /** File upload config */
+    fileConfig?: ModuleFileConfig;
+    /** Audit display config */
+    auditConfig?: ModuleAuditConfig;
+    /** Rating config */
+    ratingConfig?: {
+        max?: number;
+        allowHalf?: boolean;
+        icon?: 'star' | 'heart' | 'custom';
+    };
+    /** Slider config */
+    sliderConfig?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        marks?: Record<number, string>;
+        range?: boolean;
+    };
+    /** Rich text config */
+    richTextConfig?: {
+        toolbar?: string[];
+        maxLength?: number;
+        uploadUrl?: string;
+    };
+    /** Signature pad config */
+    signatureConfig?: {
+        /** Canvas height in pixels */
+        height?: number;
+        /** Stroke color */
+        strokeColor?: string;
+        /** Background color */
+        backgroundColor?: string;
+        /** Integration with DigitalSignatureService */
+        serviceIntegration?: {
+            /** Verify signature with server */
+            verifyUrl?: string;
+            /** Store signature to server */
+            storeUrl?: string;
+            /** Include timestamp */
+            timestamp?: boolean;
+            /** Include signer info */
+            signerInfo?: boolean;
+        };
+    };
+    /** Code editor config */
+    codeConfig?: {
+        language?: string;
+        theme?: 'light' | 'dark';
+        lineNumbers?: boolean;
+        readOnly?: boolean;
+    };
+    /** Address config */
+    addressConfig?: {
+        components?: ('street' | 'city' | 'state' | 'zip' | 'country')[];
+        autocomplete?: boolean;
+        mapPicker?: boolean;
+    };
+    /** Computed/calculated field expression */
+    computedExpression?: string;
+    /** Fields this computed depends on */
+    dependsOn?: string[];
+    /** Permission required to view field */
+    viewPermission?: string;
+    /** Permission required to edit field */
+    editPermission?: string;
+    /** Custom render function name */
+    customRenderer?: string;
+    /** Custom editor function name */
+    customEditor?: string;
+    /** Additional metadata */
+    meta?: Record<string, any>;
+}
+
+/** Enum option for badge/select renderers. */
+declare interface ModuleEnumOption {
+    value: string | number;
+    label: string;
+    color?: 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'secondary' | 'default';
+    icon?: React.ReactNode;
+}
+
+/** Export configuration. */
+declare interface ModuleExportConfig {
+    filename?: string;
+    includeHidden?: boolean;
+    selectedOnly?: boolean;
+    columns?: string[];
+    title?: string;
+    subtitle?: string;
+}
+
+/** Export format options. */
+declare type ModuleExportFormat = 'csv' | 'excel' | 'pdf' | 'json';
+
+/** Single condition for field visibility/requirement. */
+export declare interface ModuleFieldCondition {
+    field: string;
+    operator: ModuleConditionOperator;
+    value?: any;
+}
+
+/** Grid column span specification. */
+declare interface ModuleFieldLayout {
+    /** Column span (1-12) */
+    colSpan?: number;
+    /** Column span on tablet */
+    colSpanMd?: number;
+    /** Column span on mobile */
+    colSpanSm?: number;
+    /** Row span for textarea/richtext */
+    rowSpan?: number;
+    /** Start new row */
+    newRow?: boolean;
+    /** Offset columns */
+    offset?: number;
+}
+
+/** Option for select/radio/segmented fields. */
+declare interface ModuleFieldOption {
+    value: string | number;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    color?: string;
+    description?: string;
+}
+
+/** Async options loader config. */
+declare interface ModuleFieldOptionsLoader {
+    url: string;
+    method?: 'GET' | 'POST';
+    valueField?: string;
+    labelField?: string;
+    searchParam?: string;
+    dependsOn?: string[];
+    transform?: (data: any) => ModuleFieldOption[];
+}
+
+/** All supported field types for NiceModuleForm (15+ types). */
+export declare type ModuleFieldType = 'text' | 'textarea' | 'number' | 'currency' | 'percent' | 'email' | 'phone' | 'url' | 'password' | 'date' | 'datetime' | 'time' | 'daterange' | 'select' | 'multiselect' | 'combobox' | 'lookup' | 'checkbox' | 'toggle' | 'radio' | 'segmented' | 'slider' | 'rating' | 'color' | 'file' | 'image' | 'signature' | 'richtext' | 'markdown' | 'code' | 'json' | 'address' | 'coordinates' | 'audit' | 'relation' | 'tags' | 'hidden' | 'readonly';
+
+/** Validation rule for module form fields. */
+export declare interface ModuleFieldValidation {
+    type: 'required' | 'minLength' | 'maxLength' | 'min' | 'max' | 'pattern' | 'email' | 'url' | 'phone' | 'nip' | 'regon' | 'iban' | 'pesel' | 'custom' | 'unique' | 'serverValidation';
+    value?: string | number | boolean | RegExp;
+    message?: string;
+    /** Async validator URL for serverValidation */
+    validatorUrl?: string;
+}
+
+/** File upload field configuration. */
+declare interface ModuleFileConfig {
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    uploadUrl?: string;
+    multiple?: boolean;
+    showPreview?: boolean;
+    allowPaste?: boolean;
+    dragDrop?: boolean;
+}
+
+/** Single filter condition. */
+declare interface ModuleFilterCondition {
+    field: string;
+    operator: ModuleFilterOperator;
+    value: any;
+    valueTo?: any;
+}
+
+/** Filter group with AND/OR logic. */
+export declare interface ModuleFilterGroup {
+    logic: 'and' | 'or';
+    conditions: (ModuleFilterCondition | ModuleFilterGroup)[];
+}
+
+/** Filter operator types. */
+declare type ModuleFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'between' | 'isNull' | 'isNotNull';
+
+/** Form action button. */
+declare interface ModuleFormAction {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    variant?: 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger';
+    type?: 'submit' | 'button' | 'reset';
+    disabled?: boolean;
+    loading?: boolean;
+    permission?: string;
+    visibleIf?: ModuleConditionGroup | ModuleFieldCondition;
+    onClick?: () => void;
+}
+
+/** Context value for nested form components. */
+export declare interface ModuleFormContextValue<T = any> {
+    values: T;
+    errors: ModuleFormError[];
+    touched: Set<string>;
+    disabled: boolean;
+    readOnly: boolean;
+    mode: 'create' | 'edit' | 'view';
+    size: NiceSize;
+    getValue: (field: string) => any;
+    setValue: (field: string, value: any) => void;
+    getError: (field: string) => string | undefined;
+    setTouched: (field: string) => void;
+    isFieldVisible: (field: ModuleEntityField) => boolean;
+    isFieldDisabled: (field: ModuleEntityField) => boolean;
+    isFieldRequired: (field: ModuleEntityField) => boolean;
+    registerField: (field: ModuleEntityField) => void;
+    unregisterField: (fieldId: string) => void;
+}
+
+/** Form validation error. */
+export declare interface ModuleFormError {
+    field: string;
+    message: string;
+    type: string;
+}
+
+/** Form layout mode. */
+declare type ModuleFormLayout = 'vertical' | 'horizontal' | 'inline' | 'grid';
+
+/** Form section/group definition. */
+export declare interface ModuleFormSection {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    columns?: number;
+    visibleIf?: ModuleConditionGroup | ModuleFieldCondition;
+}
+
+/** Form submission state. */
+export declare interface ModuleFormState {
+    isDirty: boolean;
+    isSubmitting: boolean;
+    isValidating: boolean;
+    isValid: boolean;
+    errors: ModuleFormError[];
+    touched: Set<string>;
+    dirtyFields: Set<string>;
+}
+
+/** Form tab definition. */
+export declare interface ModuleFormTab {
+    id: string;
+    title: string;
+    icon?: React.ReactNode;
+    badge?: string | number;
+    disabled?: boolean;
+    visibleIf?: ModuleConditionGroup | ModuleFieldCondition;
+}
+
+/** Column definition from JSON schema for NiceModuleGrid. */
+export declare interface ModuleGridColumn<T = any> {
+    /** Field path in entity (supports dot notation: "address.city") */
+    field: string;
+    /** Display header (i18n key or literal) */
+    header: string;
+    /** Column width (px or 'auto') */
+    width?: number | 'auto';
+    /** Minimum column width */
+    minWidth?: number;
+    /** Maximum column width */
+    maxWidth?: number;
+    /** Enable column sorting */
+    sortable?: boolean;
+    /** Enable column filtering */
+    filterable?: boolean;
+    /** Cell renderer type */
+    type?: ModuleCellRendererType;
+    /** Custom cell renderer function */
+    render?: (value: any, row: T, index: number) => React.ReactNode;
+    /** Cell alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Hide column by default */
+    hidden?: boolean;
+    /** Pin column to left or right */
+    pinned?: 'left' | 'right';
+    /** Enable inline editing */
+    editable?: boolean;
+    /** Custom inline editor */
+    editor?: (value: any, row: T, onChange: (val: any) => void) => React.ReactNode;
+    /** Enum options for badge/select renderers */
+    enumOptions?: ModuleEnumOption[];
+    /** Format pattern (date: 'YYYY-MM-DD', number: '#,##0.00', currency: 'PLN') */
+    format?: string;
+    /** Currency code for currency renderer */
+    currencyCode?: string;
+    /** Max rating for rating renderer */
+    maxRating?: number;
+    /** Link URL template (use {{field}} for values) */
+    linkTemplate?: string;
+    /** Open link in new tab */
+    linkNewTab?: boolean;
+    /** Image thumbnail size */
+    imageSize?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Progress bar color */
+    progressColor?: 'primary' | 'success' | 'warning' | 'danger';
+    /** Tooltip for column header */
+    headerTooltip?: string;
+    /** Validation rules for inline editing */
+    validation?: {
+        required?: boolean;
+        min?: number;
+        max?: number;
+        pattern?: string;
+        message?: string;
+    };
+    /** Column group name (for grouped headers) */
+    group?: string;
+    /** Aggregate function for footer */
+    aggregate?: 'sum' | 'avg' | 'count' | 'min' | 'max';
+    /** Searchable in global search */
+    searchable?: boolean;
+    /** Export to CSV/Excel/PDF */
+    exportable?: boolean;
+}
+
+/** Server query for pagination, sorting, filtering. */
+export declare interface ModuleGridQuery {
+    page: number;
+    pageSize: number;
+    sort?: ModuleSortSpec[];
+    filter?: ModuleFilterGroup;
+    search?: string;
+    groupBy?: string;
+}
+
+/** Server response with pagination metadata. */
+export declare interface ModuleGridResponse<T> {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+    aggregates?: Record<string, number>;
+}
+
+/** Grouped row structure. */
+declare interface ModuleGroupedRow<T = any> {
+    isGroup: true;
+    groupKey: string;
+    groupValue: any;
+    groupLabel: string;
+    count: number;
+    aggregates?: Record<string, number>;
+    rows?: T[];
+    expanded?: boolean;
+    level: number;
+}
+
 /** Dynamic import function type. */
 export declare type ModuleImportFn = () => Promise<{
     default: ComponentType<Record<string, unknown>>;
 }>;
 
+/** Config for lookup/relation fields to other modules. */
+export declare interface ModuleLookupConfig {
+    /** Target module ID */
+    moduleId: string;
+    /** Fields to display in dropdown */
+    displayFields: string[];
+    /** Fields to search in */
+    searchFields: string[];
+    /** Additional query filters */
+    filters?: Record<string, any>;
+    /** Allow creating new record from lookup */
+    allowCreate?: boolean;
+    /** Quick view fields for popup preview */
+    quickViewFields?: string[];
+    /** Multiple selection */
+    multiple?: boolean;
+}
+
+/** Selection mode for grid. */
+declare type ModuleSelectionMode = 'none' | 'single' | 'multiple' | 'checkbox';
+
+/** Sort specification. */
+export declare interface ModuleSortSpec {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+
+/** User view preferences for persistence. */
+declare interface ModuleViewPreferences {
+    columnOrder?: string[];
+    columnWidths?: Record<string, number>;
+    hiddenColumns?: string[];
+    pinnedColumns?: {
+        left: string[];
+        right: string[];
+    };
+    sort?: ModuleSortSpec[];
+    filter?: ModuleFilterGroup;
+    pageSize?: number;
+    groupBy?: string;
+    displayDensity?: 'compact' | 'normal' | 'comfortable';
+}
+
 /** A breadcrumb item. */
 export declare interface NavbarBreadcrumb {
     label: string;
@@ -6244,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;
@@ -7021,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;
@@ -7041,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';
@@ -7813,6 +9665,90 @@ export declare interface NiceCompactShellProps extends NiceBaseProps {
     children?: React.ReactNode;
 }
 
+/**
+ * NiceComplianceDashboard — Compliance and certification dashboard.
+ *
+ * @example
+ * ```tsx
+ * <NiceComplianceDashboard
+ *   certifications={[
+ *     {
+ *       id: 'iso27001',
+ *       name: 'ISO 27001',
+ *       code: 'ISMS',
+ *       complianceScore: 85,
+ *       ragStatus: 'green',
+ *       status: 'active',
+ *       requirements: [...],
+ *     },
+ *   ]}
+ *   events={auditEvents}
+ *   onCertificationClick={cert => openDetails(cert)}
+ * />
+ * ```
+ */
+export declare const NiceComplianceDashboard: default_2.ForwardRefExoticComponent<NiceComplianceDashboardProps & default_2.RefAttributes<ComplianceDashboardRef>>;
+
+/**
+ * Props for NiceComplianceDashboard.
+ */
+export declare interface NiceComplianceDashboardProps extends NiceBaseProps {
+    /** Certifications */
+    certifications: Certification[];
+    /** Timeline events */
+    events?: ComplianceEvent[];
+    /** Gap items (can be derived from requirements) */
+    gaps?: GapItem[];
+    /** Checklist items */
+    checklist?: ChecklistItem[];
+    /** Cost items for budget tracking */
+    costs?: CostItem[];
+    /** Default view */
+    defaultView?: DashboardView;
+    /** Views to show */
+    views?: DashboardView[];
+    /** Allow view switching */
+    allowViewSwitch?: boolean;
+    /** Show filters */
+    showFilters?: boolean;
+    /** Show search */
+    showSearch?: boolean;
+    /** Show export button */
+    showExport?: boolean;
+    /** Called when a certification is clicked */
+    onCertificationClick?: (cert: Certification) => void;
+    /** Called when a requirement is clicked */
+    onRequirementClick?: (req: ComplianceRequirement, cert: Certification) => void;
+    /** Called when evidence is clicked */
+    onEvidenceClick?: (evidence: EvidenceItem, req: ComplianceRequirement) => void;
+    /** Called when upload evidence is requested */
+    onUploadEvidence?: (requirementId: string) => void;
+    /** Called when event is clicked */
+    onEventClick?: (event: ComplianceEvent) => void;
+    /** Called when checklist item is toggled */
+    onChecklistChange?: (item: ChecklistItem, checked: boolean) => void;
+    /** Called when cost item is updated */
+    onCostUpdate?: (item: CostItem) => void;
+    /** Called when filter changes */
+    onFilterChange?: (filter: ComplianceFilter) => void;
+    /** Called when view changes */
+    onViewChange?: (view: DashboardView) => void;
+    /** Called when export is requested */
+    onExport?: (format: 'pdf' | 'xlsx' | 'csv') => void;
+    /** Component size */
+    size?: NiceSize;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Custom labels */
+    labels?: ComplianceDashboardLabels;
+    /** Locale */
+    locale?: string;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+}
+
 export declare interface NiceComponentEntry {
     name: string;
     component: default_2.ComponentType<any>;
@@ -8018,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.
@@ -9264,6 +11229,40 @@ export declare interface NiceDocumentApprovalFlowProps extends NiceFormFieldProp
     locale?: string;
 }
 
+export declare function NiceDocumentationViewer({ doc, component, renderPreview, defaultTab, sections, compact, enableCodeEdit, className, style, }: NiceDocumentationViewerProps): JSX_2.Element;
+
+export declare interface NiceDocumentationViewerProps {
+    /** Component documentation data */
+    doc: ComponentDoc;
+    /** Optional live component for preview */
+    component?: default_2.ComponentType<Record<string, unknown>>;
+    /** Custom renderer for live preview */
+    renderPreview?: (props: Record<string, unknown>) => default_2.ReactNode;
+    /** Initial tab to show */
+    defaultTab?: DocTab;
+    /** Show/hide specific sections */
+    sections?: {
+        overview?: boolean;
+        props?: boolean;
+        events?: boolean;
+        theming?: boolean;
+        i18n?: boolean;
+        examples?: boolean;
+        accessibility?: boolean;
+        api?: boolean;
+    };
+    /** Compact mode for embedded use */
+    compact?: boolean;
+    /** Enable code editing in examples */
+    enableCodeEdit?: boolean;
+    /** Callback when code is edited */
+    onCodeChange?: (code: string, exampleIndex: number) => void;
+    /** Custom class name */
+    className?: string;
+    /** Custom styles */
+    style?: default_2.CSSProperties;
+}
+
 /** A content block in the {@link NiceDocumentEditor}. */
 export declare interface NiceDocumentBlock {
     id: string;
@@ -10499,6 +12498,102 @@ export declare interface NiceFloorPlanCanvasProps extends NiceBaseProps {
     animateStateChanges?: boolean;
 }
 
+/**
+ * NiceForecastChart — Time series chart with forecast and confidence intervals.
+ *
+ * @example
+ * ```tsx
+ * <NiceForecastChart
+ *   scenarios={[
+ *     {
+ *       id: 'base',
+ *       name: 'Base Forecast',
+ *       isBase: true,
+ *       data: historicalAndForecastData,
+ *       showConfidenceBand: true,
+ *       confidenceLevel: 95,
+ *     },
+ *     {
+ *       id: 'optimistic',
+ *       name: 'Optimistic',
+ *       data: optimisticData,
+ *     },
+ *   ]}
+ *   forecastStartDate={new Date('2026-01-01')}
+ *   annotations={[
+ *     { id: '1', date: '2025-06-15', type: 'event', label: 'Product Launch' }
+ *   ]}
+ * />
+ * ```
+ */
+export declare const NiceForecastChart: default_2.ForwardRefExoticComponent<NiceForecastChartProps & default_2.RefAttributes<ForecastChartRef>>;
+
+/**
+ * Props for NiceForecastChart component.
+ */
+export declare interface NiceForecastChartProps extends NiceBaseProps {
+    /** Scenarios to display */
+    scenarios: ForecastScenario[];
+    /** Annotations */
+    annotations?: ForecastAnnotation[];
+    /** Reference lines */
+    referenceLines?: ReferenceLine[];
+    /** Forecast start date (where dashed line begins) */
+    forecastStartDate?: Date | string | number;
+    /** Cash runway indicator (shows where cash runs out) */
+    cashRunway?: CashRunwayConfig;
+    /** X-axis config */
+    xAxis?: AxisConfig;
+    /** Y-axis config */
+    yAxis?: AxisConfig;
+    /** Default confidence bands */
+    confidenceBands?: ConfidenceBandConfig[];
+    /** Tooltip config */
+    tooltip?: TooltipConfig;
+    /** Legend config */
+    legend?: LegendConfig;
+    /** Chart height */
+    height?: number | string;
+    /** Show forecast region shading */
+    showForecastRegion?: boolean;
+    /** Forecast region color */
+    forecastRegionColor?: string;
+    /** Line width */
+    lineWidth?: number;
+    /** Show data points */
+    showPoints?: boolean;
+    /** Point radius */
+    pointRadius?: number;
+    /** Enable zoom */
+    enableZoom?: boolean;
+    /** Enable pan */
+    enablePan?: boolean;
+    /** Animation duration (ms) */
+    animationDuration?: number;
+    /** Responsive */
+    responsive?: boolean;
+    /** Called when a point is clicked */
+    onPointClick?: (point: ForecastDataPoint, scenario: ForecastScenario) => void;
+    /** Called when an annotation is clicked */
+    onAnnotationClick?: (annotation: ForecastAnnotation) => void;
+    /** Called when scenario visibility changes */
+    onScenarioToggle?: (scenarioId: string, visible: boolean) => void;
+    /** Called when zoom/pan changes */
+    onViewportChange?: (startDate: Date, endDate: Date) => void;
+    /** Component size */
+    size?: NiceSize;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Custom labels */
+    labels?: ForecastChartLabels;
+    /** Locale for formatting */
+    locale?: string;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+}
+
 export declare const NiceForm: default_2.FC<NiceFormProps>;
 
 export declare function NiceFormBuilder({ initialSchema, onChange, onExport, onPreview, className, style, }: NiceFormBuilderProps): JSX.Element;
@@ -11154,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
  *
@@ -11643,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 {
@@ -11799,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. */
@@ -11816,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}. */
@@ -11846,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.
@@ -12188,6 +14363,87 @@ export declare interface NiceLoadResult<T> {
     summary?: Record<string, unknown>;
 }
 
+/**
+ * NiceLoanCalculator — Interactive loan calculator with sliders and comparison.
+ *
+ * @example
+ * ```tsx
+ * <NiceLoanCalculator
+ *   initialParams={{ principal: 500000, annualRate: 7.5, termMonths: 240 }}
+ *   currency="PLN"
+ *   showSchedule
+ *   showChart
+ * />
+ * ```
+ */
+export declare const NiceLoanCalculator: default_2.ForwardRefExoticComponent<NiceLoanCalculatorProps & default_2.RefAttributes<LoanCalculatorRef>>;
+
+/**
+ * Props for NiceLoanCalculator component.
+ */
+export declare interface NiceLoanCalculatorProps extends NiceBaseProps {
+    /** Initial loan parameters */
+    initialParams?: Partial<LoanParameters>;
+    /** Initial comparison scenarios */
+    initialScenarios?: LoanScenario[];
+    /** Principal slider config */
+    principalConfig?: SliderConfig;
+    /** Interest rate slider config */
+    rateConfig?: SliderConfig;
+    /** Term slider config */
+    termConfig?: SliderConfig;
+    /** Available loan types */
+    loanTypes?: LoanType[];
+    /** Default loan type */
+    defaultType?: LoanType;
+    /** Currency code */
+    currency?: string;
+    /** Locale for formatting */
+    locale?: string;
+    /** Show sliders */
+    showSliders?: boolean;
+    /** Show numeric inputs alongside sliders */
+    showInputs?: boolean;
+    /** Show summary panel */
+    showSummary?: boolean;
+    /** Show comparison table */
+    showComparison?: boolean;
+    /** Show payment schedule */
+    showSchedule?: boolean;
+    /** Show chart */
+    showChart?: boolean;
+    /** Chart type */
+    chartType?: 'area' | 'bar' | 'line';
+    /** Maximum schedule rows to display (pagination) */
+    maxScheduleRows?: number;
+    /** Show export button */
+    showExport?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Called when parameters change */
+    onParamsChange?: (params: LoanParameters) => void;
+    /** Called when result is calculated */
+    onCalculate?: (result: LoanResult) => void;
+    /** Called when scenario is added */
+    onScenarioAdd?: (scenario: LoanScenario) => void;
+    /** Called when scenario is removed */
+    onScenarioRemove?: (id: string) => void;
+    /** Called when export is requested */
+    onExport?: (format: 'csv' | 'pdf' | 'xlsx', data: LoanResult) => void;
+    /** Component size */
+    size?: NiceSize;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Custom labels */
+    labels?: LoanCalculatorLabels;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+}
+
 export declare interface NiceLocaleInfo {
     code: string;
     name: string;
@@ -13250,6 +15506,326 @@ export declare interface NiceModuleDependency {
     required?: boolean;
 }
 
+/**
+ * NiceModuleForm — Dynamic form renderer for OmniVerk ERP modules.
+ *
+ * @example
+ * ```tsx
+ * <NiceModuleForm
+ *   fields={schema.fields}
+ *   initialValues={{ name: '', status: 'draft' }}
+ *   onSubmit={async (values) => {
+ *     await api.createEntity(values);
+ *   }}
+ * />
+ * ```
+ */
+export declare const NiceModuleForm: default_2.ForwardRefExoticComponent<NiceModuleFormProps<any> & default_2.RefAttributes<any>>;
+
+/**
+ * Props for NiceModuleForm — dynamic form renderer for OmniVerk modules.
+ * Supports 15+ field types with conditional fields and auto-save drafts.
+ */
+export declare interface NiceModuleFormProps<T extends Record<string, any> = any> extends NiceBaseProps {
+    /** Field definitions from JSON schema */
+    fields: ModuleEntityField[];
+    /** Section definitions */
+    sections?: ModuleFormSection[];
+    /** Tab definitions */
+    tabs?: ModuleFormTab[];
+    /** Initial/default values */
+    initialValues?: Partial<T>;
+    /** Controlled values */
+    values?: T;
+    /** Values change handler */
+    onValuesChange?: (values: T, changedField?: string) => void;
+    /** Form mode */
+    mode?: 'create' | 'edit' | 'view';
+    /** Overall read-only state */
+    readOnly?: boolean;
+    /** Overall disabled state */
+    disabled?: boolean;
+    /** Form layout mode */
+    layout?: ModuleFormLayout;
+    /** Number of columns (for grid layout) */
+    columns?: number;
+    /** Label placement for horizontal layout */
+    labelWidth?: number | string;
+    /** Compact mode */
+    compact?: boolean;
+    /** Form submit handler */
+    onSubmit?: (values: T) => Promise<void> | void;
+    /** Validation before submit */
+    onValidate?: (values: T) => Promise<ModuleFormError[]> | ModuleFormError[];
+    /** Form reset handler */
+    onReset?: () => void;
+    /** Cancel handler */
+    onCancel?: () => void;
+    /** Custom action buttons */
+    actions?: ModuleFormAction[];
+    /** Hide default submit/cancel buttons */
+    hideDefaultActions?: boolean;
+    /** Submit button text */
+    submitText?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Show reset button */
+    showReset?: boolean;
+    /** Draft auto-save config */
+    draftConfig?: ModuleDraftConfig;
+    /** Draft restore handler */
+    onDraftRestore?: (draft: Partial<T>) => void;
+    /** Draft save handler (for custom storage) */
+    onDraftSave?: (values: Partial<T>) => void;
+    /** Validation mode */
+    validationMode?: 'onChange' | 'onBlur' | 'onSubmit';
+    /** Show validation errors */
+    showErrors?: boolean;
+    /** Show validation summary at top */
+    showValidationSummary?: boolean;
+    /** External errors (from server) */
+    externalErrors?: ModuleFormError[];
+    /** Global options fetcher */
+    fetchOptions?: (loader: ModuleFieldOptionsLoader, dependencyValues?: Record<string, any>) => Promise<ModuleFieldOption[]>;
+    /** Lookup search handler */
+    onLookupSearch?: (config: ModuleLookupConfig, searchText: string) => Promise<any[]>;
+    /** Custom field renderers by name */
+    customRenderers?: Record<string, (field: ModuleEntityField, value: any, onChange: (val: any) => void) => React.ReactNode>;
+    /** Custom section renderer */
+    renderSection?: (section: ModuleFormSection, children: React.ReactNode) => React.ReactNode;
+    /** Custom tab renderer */
+    renderTab?: (tab: ModuleFormTab, children: React.ReactNode) => React.ReactNode;
+    /** Field focus handler */
+    onFieldFocus?: (fieldId: string) => void;
+    /** Field blur handler */
+    onFieldBlur?: (fieldId: string, value: any) => void;
+    /** Dirty state change handler */
+    onDirtyChange?: (isDirty: boolean) => void;
+    /** Module ID for permissions */
+    moduleId?: string;
+    /** Entity ID (for edit mode) */
+    entityId?: string | number;
+    /** User permissions */
+    permissions?: Record<string, boolean>;
+    /** Loading state */
+    loading?: boolean;
+    /** Submitting state */
+    submitting?: boolean;
+    /** Component size */
+    size?: NiceSize;
+    /** Form aria-label */
+    'aria-label'?: string;
+    /** Form aria-labelledby */
+    'aria-labelledby'?: string;
+    /** Required field indicator */
+    requiredIndicator?: React.ReactNode;
+}
+
+/**
+ * NiceModuleGrid — Enterprise data grid for OmniVerk ERP modules.
+ *
+ * - JSON schema column configuration for 527+ entities
+ * - Virtual scrolling for 100K+ rows
+ * - Server-side pagination, sorting, filtering
+ * - Mobile responsive card view
+ * - Export to CSV/Excel/PDF
+ * - Inline editing with validation
+ * - Row grouping and aggregates
+ * - Column reorder, resize, pinning
+ * - Multi-select with checkbox
+ * - Context menu with permissions
+ * - View preferences persistence
+ * - Dark mode, RTL, WCAG 2.1 AA
+ *
+ * @example Basic usage
+ * ```tsx
+ * <NiceModuleGrid
+ *   columns={moduleColumns}
+ *   data={moduleData}
+ *   keyField="id"
+ *   selectionMode="checkbox"
+ *   onRowClick={(row) => navigate(`/module/${row.id}`)}
+ * />
+ * ```
+ *
+ * @example Server-side mode
+ * ```tsx
+ * <NiceModuleGrid
+ *   columns={columns}
+ *   onFetch={async (query) => {
+ *     const res = await api.fetchModuleData(query);
+ *     return { data: res.items, total: res.total, page: query.page, pageSize: query.pageSize, hasMore: res.hasMore };
+ *   }}
+ *   pagination
+ *   sortable
+ *   filterable
+ * />
+ * ```
+ */
+export declare const NiceModuleGrid: <T extends Record<string, any>>(props: NiceModuleGridProps<T> & {
+    ref?: ForwardedRef<HTMLDivElement>;
+}) => ReturnType<typeof NiceModuleGridInner>;
+
+declare function NiceModuleGridInner<T extends Record<string, any>>(props: NiceModuleGridProps<T>, ref: ForwardedRef<HTMLDivElement>): JSX_2.Element;
+
+/**
+ * Props for NiceModuleGrid — enterprise data grid for OmniVerk modules.
+ * Supports 527+ entity definitions with JSON schema configuration.
+ */
+export declare interface NiceModuleGridProps<T extends Record<string, any> = any> extends NiceBaseProps {
+    /** Column definitions from JSON schema */
+    columns: ModuleGridColumn<T>[];
+    /** Static data array (for client-side mode) */
+    data?: T[];
+    /** Key field for row identification */
+    keyField?: string;
+    /** Data source binding for server-side operations */
+    dataSource?: NiceDataSource<T>;
+    /** Async data fetcher for server-side mode */
+    onFetch?: (query: ModuleGridQuery) => Promise<ModuleGridResponse<T>>;
+    /** Enable sorting */
+    sortable?: boolean;
+    /** Current sort specifications */
+    sort?: ModuleSortSpec[];
+    /** Sort change handler (for server-side) */
+    onSortChange?: (sort: ModuleSortSpec[]) => void;
+    /** Multi-column sort */
+    multiSort?: boolean;
+    /** Enable column filtering */
+    filterable?: boolean;
+    /** Current filter state */
+    filter?: ModuleFilterGroup;
+    /** Filter change handler */
+    onFilterChange?: (filter: ModuleFilterGroup) => void;
+    /** Quick search text */
+    searchText?: string;
+    /** Search change handler */
+    onSearchChange?: (text: string) => void;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Enable pagination */
+    pagination?: boolean;
+    /** Current page (1-indexed) */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+    /** Available page sizes */
+    pageSizeOptions?: number[];
+    /** Total row count (for server-side) */
+    totalRows?: number;
+    /** Page change handler */
+    onPageChange?: (page: number, pageSize: number) => void;
+    /** Enable virtual scrolling (for 100K+ rows) */
+    virtualScroll?: boolean;
+    /** Row height for virtual scrolling */
+    rowHeight?: number;
+    /** Overscan count for virtual scrolling */
+    overscan?: number;
+    /** Selection mode */
+    selectionMode?: ModuleSelectionMode;
+    /** Selected row keys */
+    selectedKeys?: Set<string>;
+    /** Selection change handler */
+    onSelectionChange?: (keys: Set<string>, rows: T[]) => void;
+    /** Select all with server count */
+    selectAllServerCount?: number;
+    /** Select all handler for server-side */
+    onSelectAll?: () => Promise<Set<string>>;
+    /** Enable column reordering */
+    columnReorder?: boolean;
+    /** Column order change handler */
+    onColumnOrderChange?: (order: string[]) => void;
+    /** Enable column resizing */
+    columnResize?: boolean;
+    /** Column width change handler */
+    onColumnWidthChange?: (field: string, width: number) => void;
+    /** Column visibility change handler */
+    onColumnVisibilityChange?: (field: string, visible: boolean) => void;
+    /** Group by field */
+    groupBy?: string;
+    /** Group change handler */
+    onGroupByChange?: (field: string | null) => void;
+    /** Custom group row renderer */
+    groupRowRender?: (group: ModuleGroupedRow<T>) => React.ReactNode;
+    /** Expand all groups by default */
+    expandAllGroups?: boolean;
+    /** Enable inline editing */
+    editable?: boolean;
+    /** Cell edit handler */
+    onCellEdit?: (rowKey: string, field: string, value: any, row: T) => Promise<boolean> | boolean;
+    /** Row edit handler */
+    onRowEdit?: (rowKey: string, values: Partial<T>, row: T) => Promise<boolean> | boolean;
+    /** Edit mode: cell or row */
+    editMode?: 'cell' | 'row';
+    /** Validation error handler */
+    onValidationError?: (rowKey: string, field: string, error: string) => void;
+    /** Context menu items */
+    contextMenuItems?: ModuleContextMenuItem<T>[];
+    /** Context menu action handler */
+    onContextMenuAction?: (action: string, row: T) => void;
+    /** Enable export */
+    exportable?: boolean;
+    /** Available export formats */
+    exportFormats?: ModuleExportFormat[];
+    /** Export handler (for server-side) */
+    onExport?: (format: ModuleExportFormat, config: ModuleExportConfig) => Promise<void>;
+    /** Storage key for preferences persistence */
+    preferencesKey?: string;
+    /** Initial preferences */
+    initialPreferences?: ModuleViewPreferences;
+    /** Preferences change handler */
+    onPreferencesChange?: (prefs: ModuleViewPreferences) => void;
+    /** Display density */
+    density?: 'compact' | 'normal' | 'comfortable';
+    /** Striped rows */
+    striped?: boolean;
+    /** Show borders */
+    bordered?: boolean;
+    /** Hover highlight */
+    hoverable?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Empty state configuration */
+    emptyState?: ModuleEmptyState;
+    /** Custom toolbar */
+    toolbar?: React.ReactNode;
+    /** Row click handler */
+    onRowClick?: (row: T, index: number) => void;
+    /** Row double-click handler */
+    onRowDoubleClick?: (row: T, index: number) => void;
+    /** Custom row class/style */
+    rowClassName?: string | ((row: T, index: number) => string);
+    rowStyle?: React.CSSProperties | ((row: T, index: number) => React.CSSProperties);
+    /** Enable mobile card view */
+    mobileCardView?: boolean;
+    /** Mobile breakpoint (px) */
+    mobileBreakpoint?: number;
+    /** Custom mobile card renderer */
+    mobileCardRender?: (row: T, index: number) => React.ReactNode;
+    /** Primary field for mobile card title */
+    mobilePrimaryField?: string;
+    /** Secondary field for mobile card subtitle */
+    mobileSecondaryField?: string;
+    /** Module ID for permissions */
+    moduleId?: string;
+    /** Module permission for context menu filtering */
+    permissions?: Record<string, boolean>;
+    /** Component size */
+    size?: NiceSize;
+    /** Show skeleton loading per column */
+    skeletonLoading?: boolean;
+    /** Number of skeleton rows */
+    skeletonRows?: number;
+    /** ARIA label */
+    'aria-label'?: string;
+    /** ARIA labelledby */
+    'aria-labelledby'?: string;
+    /** ARIA describedby */
+    'aria-describedby'?: string;
+    /** Test ID for testing frameworks */
+    testId?: string;
+}
+
 /** Manages runtime module replacement. */
 export declare class NiceModuleHotSwap {
     private resolver;
@@ -14829,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
  *
@@ -15082,6 +17674,95 @@ export declare interface NiceRealtimeChartRef {
     getData: () => RealtimeDataPoint[];
 }
 
+/**
+ * NiceReconciliationView — Bank reconciliation split-view with drag-drop matching.
+ *
+ * @example
+ * ```tsx
+ * <NiceReconciliationView
+ *   statements={bankStatements}
+ *   entries={bookEntries}
+ *   onMatch={handleMatch}
+ *   config={{ amountTolerance: 0.01, enableAI: true }}
+ * />
+ * ```
+ */
+export declare const NiceReconciliationView: default_2.ForwardRefExoticComponent<NiceReconciliationViewProps & default_2.RefAttributes<ReconciliationViewRef>>;
+
+/**
+ * Props for NiceReconciliationView component.
+ */
+export declare interface NiceReconciliationViewProps extends NiceBaseProps {
+    /** Bank statement items */
+    statements: BankStatementItem[];
+    /** Book entries from ledger */
+    entries: BookEntry[];
+    /** Existing matches (controlled) */
+    matches?: ReconciliationMatch[];
+    /** Initial matches (uncontrolled) */
+    defaultMatches?: ReconciliationMatch[];
+    /** AI suggestions */
+    suggestions?: AISuggestion[];
+    /** Reconciliation config */
+    config?: ReconciliationConfig;
+    /** Statement panel config */
+    statementPanelConfig?: PanelConfig;
+    /** Entry panel config */
+    entryPanelConfig?: PanelConfig;
+    /** Called when items are matched */
+    onMatch?: OnMatchCallback;
+    /** Called when match is removed */
+    onUnmatch?: OnUnmatchCallback;
+    /** Called for batch actions */
+    onBatchAction?: OnBatchActionCallback;
+    /** Called when filter changes */
+    onFilterChange?: OnFilterChangeCallback;
+    /** Called to request AI suggestions */
+    onRequestSuggestions?: OnRequestSuggestionsCallback;
+    /** Called when selection changes */
+    onSelectionChange?: (statementIds: string[], entryIds: string[]) => void;
+    /** Called when reconciliation is complete */
+    onComplete?: (summary: ReconciliationSummary) => void;
+    /** Component size */
+    size?: NiceSize;
+    /** Show toolbar */
+    showToolbar?: boolean;
+    /** Show filter panel */
+    showFilters?: boolean;
+    /** Show summary footer */
+    showSummary?: boolean;
+    /** Show AI suggestions panel */
+    showSuggestions?: boolean;
+    /** Panel layout */
+    layout?: 'horizontal' | 'vertical';
+    /** Initial panel sizes (percentage) */
+    panelSizes?: [number, number];
+    /** Resizable panels */
+    resizable?: boolean;
+    /** Collapsible panels */
+    collapsible?: boolean;
+    /** Enable drag-and-drop */
+    enableDragDrop?: boolean;
+    /** Enable keyboard shortcuts */
+    enableKeyboard?: boolean;
+    /** Enable detail panel on double-click (side-by-side view) */
+    enableDetailPanel?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Locale for number/date formatting */
+    locale?: string;
+    /** Custom labels */
+    labels?: ReconciliationLabels;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles */
+    style?: React.CSSProperties;
+}
+
 export declare interface NiceRecordState<T> {
     /** Original loaded data. */
     data: T | undefined;
@@ -15843,6 +18524,89 @@ export declare interface NiceSensorGaugePanelProps extends NiceBaseProps {
     animate?: boolean;
 }
 
+/**
+ * {@link NiceSetupWizard} — Advanced multi-step setup wizard with branching, quick mode, and schema-driven forms.
+ *
+ * @example
+ * ```tsx
+ * <NiceSetupWizard
+ *   layout="sidebar"
+ *   steps={[
+ *     { id: 'welcome', title: 'Welcome', content: <WelcomeScreen /> },
+ *     { id: 'account', title: 'Account', fields: [
+ *       { id: 'email', type: 'email', label: 'Email', required: true },
+ *       { id: 'password', type: 'password', label: 'Password', required: true },
+ *     ]},
+ *     { id: 'preferences', title: 'Preferences', optional: true, quickModeSkip: true },
+ *     { id: 'done', title: 'Complete', content: <CompleteScreen /> },
+ *   ]}
+ *   onComplete={(values) => saveUser(values)}
+ * />
+ * ```
+ */
+export declare const NiceSetupWizard: default_2.ForwardRefExoticComponent<NiceSetupWizardProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props */
+export declare interface NiceSetupWizardProps {
+    /** Step definitions */
+    steps: SetupWizardStep[];
+    /** Initial values */
+    initialValues?: Record<string, unknown>;
+    /** Controlled current step */
+    activeStep?: string;
+    /** Layout variant */
+    layout?: SetupWizardLayout;
+    /** Size */
+    size?: NiceSize;
+    /** Whether quick mode is enabled by default */
+    defaultQuickMode?: boolean;
+    /** Allow toggling quick mode */
+    allowQuickModeToggle?: boolean;
+    /** Show step numbers */
+    showStepNumbers?: boolean;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** Show estimated time */
+    showEstimatedTime?: boolean;
+    /** Allow clicking on step indicators to navigate */
+    allowStepClick?: boolean;
+    /** Show review step before completion */
+    showReviewStep?: boolean;
+    /** Persist progress to localStorage */
+    persistKey?: string;
+    /** Animation type */
+    animation?: 'slide' | 'fade' | 'none';
+    /** Brand/logo element */
+    branding?: default_2.ReactNode;
+    /** Header content */
+    header?: default_2.ReactNode;
+    /** Footer content */
+    footer?: default_2.ReactNode;
+    /** Callbacks */
+    onStepChange?: (stepId: string, index: number) => void;
+    onValuesChange?: (values: Record<string, unknown>) => void;
+    onComplete?: (values: Record<string, unknown>) => void | Promise<void>;
+    onCancel?: () => void;
+    /** Custom labels */
+    labels?: {
+        next?: string;
+        prev?: string;
+        finish?: string;
+        cancel?: string;
+        skip?: string;
+        quickMode?: string;
+        required?: string;
+        optional?: string;
+        review?: string;
+        stepOf?: string;
+    };
+    /** Accessibility */
+    accessMode?: NiceAccessMode;
+    id?: string;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
 export declare interface NiceShellProps extends NiceBaseProps {
     /** Navigation data for sidebar / menus. */
     menu?: NiceUserMenuResponse;
@@ -17470,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;
@@ -20388,6 +23201,31 @@ export declare interface OAuthConfigTemplate {
     grantTypes: ('authorization_code' | 'client_credentials' | 'refresh_token')[];
 }
 
+/**
+ * Callback for batch operations.
+ */
+declare type OnBatchActionCallback = (action: 'autoMatch' | 'approveAll' | 'clearAll' | 'exportMatched', matches: ReconciliationMatch[]) => void | Promise<void>;
+
+/**
+ * Callback when filter changes.
+ */
+declare type OnFilterChangeCallback = (filter: ReconciliationFilter) => void;
+
+/**
+ * Callback when items are matched.
+ */
+declare type OnMatchCallback = (match: ReconciliationMatch, statements: BankStatementItem[], entries: BookEntry[]) => void | Promise<void>;
+
+/**
+ * Callback for AI suggestions request.
+ */
+declare type OnRequestSuggestionsCallback = (statementIds: string[]) => Promise<AISuggestion[]>;
+
+/**
+ * Callback when match is removed.
+ */
+declare type OnUnmatchCallback = (matchId: string, statementIds: string[], entryIds: string[]) => void | Promise<void>;
+
 export declare interface OpenAPIGeneratedUI {
     columns: GridColumnDef[];
     formFields: FormFieldDef[];
@@ -20448,6 +23286,76 @@ export declare type Orientation = 'portrait' | 'landscape';
 /** Overlay position */
 export declare type OverlayPosition = 'top-left' | 'top-center' | 'top-right' | 'middle-left' | 'middle-center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
 
+/**
+ * Package-level documentation
+ */
+export declare interface PackageDoc {
+    $schema?: string;
+    /** Package name (e.g., "@nice2dev/ui") */
+    name: string;
+    /** Display name */
+    displayName: string;
+    /** Package description */
+    description: string;
+    /** Installation instructions */
+    installation: string;
+    /** Quick start guide */
+    quickStart: string;
+    /** Peer dependencies */
+    peerDependencies?: Array<{
+        name: string;
+        version: string;
+        optional?: boolean;
+    }>;
+    /** All components in this package */
+    components: string[];
+    /** Categories available */
+    categories: Array<{
+        id: string;
+        name: string;
+        icon?: string;
+        description?: string;
+    }>;
+}
+
+/**
+ * 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.
+ */
+declare interface PanelConfig {
+    /** Panel title */
+    title?: string;
+    /** Show totals footer */
+    showTotals?: boolean;
+    /** Visible columns */
+    columns?: string[];
+    /** Allow sorting */
+    sortable?: boolean;
+    /** Allow filtering */
+    filterable?: boolean;
+    /** Row height */
+    rowHeight?: number;
+    /** Custom row renderer */
+    renderRow?: (item: BankStatementItem | BookEntry, context: RowContext) => ReactNode;
+    /** Custom header */
+    renderHeader?: () => ReactNode;
+    /** Empty state message */
+    emptyMessage?: string;
+}
+
 /**
  * Pan gesture event
  */
@@ -20481,6 +23389,39 @@ export declare function parseTokensFromCSS(css: string): FigmaDesignToken[];
 /** Parse design tokens from a flat JSON token file (Style Dictionary format). */
 export declare function parseTokensFromJSON(json: Record<string, unknown>): FigmaDesignToken[];
 
+/**
+ * Payment frequency.
+ */
+declare type PaymentFrequency = 'monthly' | 'quarterly' | 'semi-annual' | 'annual';
+
+/**
+ * Single payment in amortization schedule.
+ */
+export declare interface PaymentScheduleItem {
+    /** Payment number (1-based) */
+    number: number;
+    /** Payment date */
+    date: Date;
+    /** Payment amount */
+    payment: number;
+    /** Principal portion */
+    principal: number;
+    /** Interest portion */
+    interest: number;
+    /** Extra payment */
+    extraPayment: number;
+    /** Insurance */
+    insurance: number;
+    /** Total payment (payment + extra + insurance) */
+    totalPayment: number;
+    /** Remaining balance after payment */
+    balance: number;
+    /** Cumulative principal paid */
+    cumulativePrincipal: number;
+    /** Cumulative interest paid */
+    cumulativeInterest: number;
+}
+
 export declare const PayPalConnector: ConnectorDefinition;
 
 /** A single PDF annotation. */
@@ -20783,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;
@@ -21010,6 +23956,11 @@ export declare const RADIUS_VALUES: Record<RadiusVariant, Record<string, string>
  */
 export declare type RadiusVariant = 'none' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
 
+/**
+ * RAG (Red-Amber-Green) status.
+ */
+export declare type RAGStatus = 'red' | 'amber' | 'green' | 'grey';
+
 export declare function randomPalette(mode: NiceHarmonyMode, count: number, distance?: number): string[];
 
 /** Rate control mode */
@@ -21051,6 +24002,211 @@ export declare interface RealtimeDataPoint {
     label?: string;
 }
 
+/**
+ * Reconciliation view configuration.
+ */
+export declare interface ReconciliationConfig {
+    /** Amount tolerance for matching (absolute value) */
+    amountTolerance?: number;
+    /** Amount tolerance as percentage (0-100) */
+    amountTolerancePercent?: number;
+    /** Date tolerance in days */
+    dateTolerance?: number;
+    /** Allow N:M matching */
+    allowMultiMatch?: boolean;
+    /** Allow partial matches */
+    allowPartialMatch?: boolean;
+    /** Enable AI suggestions */
+    enableAI?: boolean;
+    /** AI confidence threshold for auto-match */
+    aiAutoMatchThreshold?: number;
+    /** Currency for display */
+    currency?: string;
+    /** Locale for formatting */
+    locale?: string;
+    /** Matching rules */
+    rules?: MatchingRule[];
+}
+
+/**
+ * Filter configuration for reconciliation view.
+ */
+export declare interface ReconciliationFilter {
+    /** Date range start */
+    dateFrom?: Date | string;
+    /** Date range end */
+    dateTo?: Date | string;
+    /** Status filter */
+    status?: ReconciliationStatus[];
+    /** Amount range min */
+    amountMin?: number;
+    /** Amount range max */
+    amountMax?: number;
+    /** Search text */
+    searchText?: string;
+    /** Show only AI suggestions */
+    onlyWithSuggestions?: boolean;
+    /** Minimum AI confidence */
+    minConfidence?: number;
+}
+
+/**
+ * Custom labels for localization.
+ */
+declare interface ReconciliationLabels {
+    statementPanelTitle?: string;
+    entryPanelTitle?: string;
+    matched?: string;
+    partial?: string;
+    unmatched?: string;
+    excluded?: string;
+    autoMatch?: string;
+    clearAll?: string;
+    approveAll?: string;
+    exportMatched?: string;
+    noStatements?: string;
+    noEntries?: string;
+    noMatches?: string;
+    aiSuggestions?: string;
+    applySuggestion?: string;
+    ignoreSuggestion?: string;
+    confidence?: string;
+    difference?: string;
+    summary?: string;
+    total?: string;
+    matchedAmount?: string;
+    unmatchedAmount?: string;
+    statementDetails?: string;
+    entryDetails?: string;
+    transactionInfo?: string;
+    entryInfo?: string;
+    matchedWith?: string;
+    matchedByAI?: string;
+    matchedManually?: string;
+    statementTotal?: string;
+    entryTotal?: string;
+    date?: string;
+    description?: string;
+    amount?: string;
+    counterparty?: string;
+    accountNumber?: string;
+    party?: string;
+    documentRef?: string;
+    reference?: string;
+    matchedEntries?: string;
+    matchedStatements?: string;
+}
+
+/**
+ * A match between bank statement and book entries.
+ * Supports 1:1, 1:N, N:1, N:M matching.
+ */
+export declare interface ReconciliationMatch {
+    /** Unique match ID */
+    id: string;
+    /** Bank statement item IDs */
+    statementIds: string[];
+    /** Book entry IDs */
+    entryIds: string[];
+    /** Match status */
+    status: ReconciliationStatus;
+    /** Total statement amount */
+    statementTotal: number;
+    /** Total book amount */
+    entryTotal: number;
+    /** Difference */
+    difference: number;
+    /** AI confidence score (0-100) */
+    confidence: number;
+    /** Match reason / explanation */
+    reason?: string;
+    /** Matched by user or auto */
+    matchedBy: 'user' | 'auto' | 'ai';
+    /** Timestamp */
+    matchedAt: Date | string;
+    /** Notes / comments */
+    notes?: string;
+}
+
+/**
+ * Reconciliation match status.
+ */
+export declare type ReconciliationStatus = 'matched' | 'partial' | 'unmatched' | 'excluded';
+
+/**
+ * Reconciliation summary statistics.
+ */
+export declare interface ReconciliationSummary {
+    /** Total statement items */
+    totalStatements: number;
+    /** Total book entries */
+    totalEntries: number;
+    /** Matched statement items */
+    matchedStatements: number;
+    /** Matched book entries */
+    matchedEntries: number;
+    /** Unmatched statement items */
+    unmatchedStatements: number;
+    /** Unmatched book entries */
+    unmatchedEntries: number;
+    /** Total statement amount */
+    statementTotal: number;
+    /** Total entry amount */
+    entryTotal: number;
+    /** Matched amount */
+    matchedAmount: number;
+    /** Unmatched statement amount */
+    unmatchedStatementAmount: number;
+    /** Unmatched entry amount */
+    unmatchedEntryAmount: number;
+    /** Difference */
+    difference: number;
+    /** Match percentage */
+    matchPercentage: number;
+    /** Number of matches */
+    matchCount: number;
+    /** Partial matches */
+    partialMatchCount: number;
+    /** AI suggestions pending */
+    pendingSuggestions: number;
+}
+
+/**
+ * Imperative handle for NiceReconciliationView.
+ */
+export declare interface ReconciliationViewRef {
+    /** Get current matches */
+    getMatches(): ReconciliationMatch[];
+    /** Get unmatched statement items */
+    getUnmatchedStatements(): BankStatementItem[];
+    /** Get unmatched book entries */
+    getUnmatchedEntries(): BookEntry[];
+    /** Create a match programmatically */
+    createMatch(statementIds: string[], entryIds: string[]): ReconciliationMatch | null;
+    /** Remove a match */
+    removeMatch(matchId: string): void;
+    /** Run auto-matching */
+    autoMatch(): Promise<ReconciliationMatch[]>;
+    /** Request AI suggestions */
+    getSuggestions(statementIds?: string[]): Promise<AISuggestion[]>;
+    /** Apply AI suggestion */
+    applySuggestion(suggestion: AISuggestion): ReconciliationMatch | null;
+    /** Approve all matched items */
+    approveAll(): void;
+    /** Clear all matches */
+    clearAll(): void;
+    /** Export matched data */
+    exportMatched(format: 'csv' | 'json' | 'xlsx'): void;
+    /** Get reconciliation summary */
+    getSummary(): ReconciliationSummary;
+    /** Reset view state */
+    reset(): void;
+    /** Focus statement panel */
+    focusStatements(): void;
+    /** Focus entries panel */
+    focusEntries(): void;
+}
+
 export declare interface RectangleAnnotation extends AnnotationBase {
     tool: 'rectangle';
 }
@@ -21066,6 +24222,22 @@ export declare type ReduxMiddleware = (store: {
     dispatch: (action: ReduxAction) => void;
 }) => (next: (action: ReduxAction) => unknown) => (action: ReduxAction) => unknown;
 
+/**
+ * Reference line.
+ */
+declare interface ReferenceLine {
+    /** Unique ID */
+    id: string;
+    /** Y value */
+    value: number;
+    /** Label */
+    label?: string;
+    /** Color */
+    color?: string;
+    /** Dash pattern */
+    dashArray?: string;
+}
+
 export declare type RefreshState = 'idle' | 'pulling' | 'ready' | 'refreshing' | 'success' | 'error';
 
 /** Removes all theme CSS custom properties from the target element. */
@@ -21205,6 +24377,11 @@ export declare const requireGridColumns: ESLintRule;
 /** Require i18n labels on Nice components instead of hardcoded strings. */
 export declare const requireI18n: ESLintRule;
 
+/**
+ * Compliance requirement status.
+ */
+export declare type RequirementStatus = 'not-started' | 'in-progress' | 'compliant' | 'non-compliant' | 'deferred' | 'not-applicable';
+
 /** Output resolution */
 export declare interface Resolution {
     width: number;
@@ -21217,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;
@@ -21337,6 +24520,24 @@ export declare interface RotateEvent {
     center: Point;
 }
 
+/**
+ * Row render context.
+ */
+declare interface RowContext {
+    /** Is row selected */
+    isSelected: boolean;
+    /** Is row being dragged */
+    isDragging: boolean;
+    /** Is row a drop target */
+    isDropTarget: boolean;
+    /** Match suggestion if any */
+    suggestion?: AISuggestion;
+    /** Status */
+    status: ReconciliationStatus;
+    /** Index */
+    index: number;
+}
+
 declare interface RTLContextValue {
     direction: 'ltr' | 'rtl';
     isRTL: boolean;
@@ -21669,6 +24870,11 @@ export declare interface ScreenInfo {
 declare type ScreenOrientation_2 = 'portrait' | 'landscape';
 export { ScreenOrientation_2 as ScreenOrientation }
 
+/**
+ * Search documentation content
+ */
+export declare function searchDocs(docs: ComponentDoc[], query: string): ComponentDoc[];
+
 /** Search filter */
 export declare interface SearchFilter {
     query?: string;
@@ -21739,11 +24945,124 @@ export declare function serializeView(view: NiceViewDefinition): string;
 
 export declare function serializeViewV2(view: NiceViewDefinitionV2): string;
 
+/** Field definition for schema-driven forms */
+export declare interface SetupField {
+    id: string;
+    type: SetupFieldType;
+    label: string;
+    placeholder?: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: Array<{
+        value: string;
+        label: string;
+        icon?: default_2.ReactNode;
+    }>;
+    validation?: {
+        pattern?: RegExp;
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        custom?: (value: unknown) => string | undefined;
+    };
+    /** Show field only when condition is met */
+    showWhen?: (values: Record<string, unknown>) => boolean;
+    /** Full-width in grid layout */
+    fullWidth?: boolean;
+    /** Custom render function */
+    render?: (props: {
+        value: unknown;
+        onChange: (v: unknown) => void;
+        field: SetupField;
+    }) => default_2.ReactNode;
+}
+
+/** Step field types for schema-driven content */
+export declare type SetupFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'switch' | 'date' | 'time' | 'datetime' | 'color' | 'file' | 'slider' | 'rating' | 'custom';
+
 /**
  * Setup integration with React DevTools Profiler
  */
 export declare function setupReactDevToolsIntegration(): void;
 
+/** Custom action button */
+export declare interface SetupWizardAction {
+    id: string;
+    label: string;
+    variant?: 'primary' | 'secondary' | 'outlined' | 'text' | 'danger';
+    icon?: default_2.ReactNode;
+    onClick: (ctx: SetupWizardContext) => void;
+    disabled?: (ctx: SetupWizardContext) => boolean;
+    position?: 'left' | 'right';
+}
+
+/** Context provided to steps */
+export declare interface SetupWizardContext {
+    values: Record<string, unknown>;
+    setValue: (key: string, value: unknown) => void;
+    setValues: (vals: Record<string, unknown>) => void;
+    currentStep: SetupWizardStep;
+    currentIndex: number;
+    totalSteps: number;
+    visitedSteps: Set<string>;
+    errors: Record<string, string>;
+    setError: (stepId: string, error: string) => void;
+    clearError: (stepId: string) => void;
+    goNext: () => Promise<void>;
+    goPrev: () => void;
+    goTo: (stepId: string) => void;
+    skip: () => void;
+    complete: () => void;
+    cancel: () => void;
+    isFirst: boolean;
+    isLast: boolean;
+    isQuickMode: boolean;
+    toggleQuickMode: () => void;
+    progress: number;
+    t: (key: string, defaultValue: string) => string;
+}
+
+/** Layout variant */
+export declare type SetupWizardLayout = 'horizontal' | 'vertical' | 'cards' | 'minimal' | 'sidebar';
+
+/** Step definition */
+export declare interface SetupWizardStep {
+    id: string;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    icon?: default_2.ReactNode;
+    /** Schema-driven fields */
+    fields?: SetupField[];
+    /** OR custom content */
+    content?: default_2.ReactNode | ((ctx: SetupWizardContext) => default_2.ReactNode);
+    /** Validation function */
+    validate?: (values: Record<string, unknown>) => Promise<string | undefined> | string | undefined;
+    /** Whether step is optional */
+    optional?: boolean;
+    /** Whether step is skippable in quick mode */
+    quickModeSkip?: boolean;
+    /** Custom action buttons */
+    actions?: SetupWizardAction[];
+    /** Next step override (for branching) */
+    nextStep?: string | ((values: Record<string, unknown>) => string);
+    /** Previous step override */
+    prevStep?: string;
+    /** Minimum time on step (ms) - for steps that need time to process */
+    minDuration?: number;
+    /** Summary to show in review step */
+    summary?: (values: Record<string, unknown>) => default_2.ReactNode;
+    /** Category/group for sidebar layout */
+    category?: string;
+    /** Badge to show on step indicator */
+    badge?: default_2.ReactNode;
+    /** Estimated time to complete (displayed to user) */
+    estimatedTime?: string;
+}
+
 /**
  * Shadow intensity multipliers for dark mode
  */
@@ -21994,6 +25313,22 @@ declare interface SLAPolicy {
 
 declare type SLAStatus = 'ok' | 'warning' | 'breached';
 
+/**
+ * Slider configuration.
+ */
+declare interface SliderConfig {
+    /** Minimum value */
+    min: number;
+    /** Maximum value */
+    max: number;
+    /** Step */
+    step: number;
+    /** Default value */
+    defaultValue?: number;
+    /** Format function for display */
+    format?: (value: number) => string;
+}
+
 /**
  * Slider mark
  */
@@ -22175,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;
@@ -22345,6 +25773,19 @@ export declare interface SubtitleSettings {
 
 export declare type SuggestedChartType = 'line' | 'bar' | 'area' | 'pie' | 'donut' | 'scatter';
 
+/**
+ * Factor contributing to AI suggestion.
+ */
+declare interface SuggestionFactor {
+    /** Factor name */
+    name: string;
+    /** Contribution weight */
+    weight: number;
+    /** Matched values */
+    statementValue?: string;
+    entryValue?: string;
+}
+
 export declare interface SurveyAnswer {
     questionId: string;
     value: string | string[] | number | null;
@@ -22791,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;
@@ -22811,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;
@@ -22845,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;
@@ -23058,6 +26541,38 @@ export declare function tokensToNiceTheme(tokens: FigmaDesignToken[]): {
     warnings: string[];
 };
 
+/**
+ * Tooltip configuration.
+ */
+declare interface TooltipConfig {
+    /** Show tooltip */
+    enabled?: boolean;
+    /** Custom renderer */
+    render?: (data: TooltipData) => ReactNode;
+    /** Date format */
+    dateFormat?: string;
+    /** Value format */
+    valueFormat?: (value: number) => string;
+}
+
+/**
+ * Data passed to tooltip renderer.
+ */
+declare interface TooltipData {
+    /** Date */
+    date: Date;
+    /** Values by scenario */
+    values: Array<{
+        scenario: ForecastScenario;
+        value: number | undefined;
+        forecast: number | undefined;
+        lowerBound: number | undefined;
+        upperBound: number | undefined;
+    }>;
+    /** Annotations at this date */
+    annotations: ForecastAnnotation[];
+}
+
 /**
  * Tooltip style variants
  */
@@ -23229,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;
@@ -23553,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 {
@@ -23904,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 {
@@ -23927,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.
@@ -24027,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;
@@ -24131,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.
  */
@@ -24404,6 +28347,8 @@ export declare interface UseModalReturn {
     setOpen: (open: boolean) => void;
 }
 
+export declare function useModuleForm(): ModuleFormContextValue<any>;
+
 /** Hook to access the module loader. */
 export declare function useModuleLoader(): NiceModuleLoaderContextValue;
 
@@ -24491,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.
@@ -24625,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.
  */
@@ -24736,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 */
@@ -24983,6 +28955,9 @@ export declare function useSafeWebSocket(url: string | null, protocols?: string
  */
 export declare function useSelectionHaptic(): () => void;
 
+/** Hook to access wizard context from within steps */
+export declare function useSetupWizard(): SetupWizardContext;
+
 /**
  * Hook to determine visibility based on breakpoint.
  */
@@ -25028,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;
 
 /**
@@ -25160,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;
@@ -25318,6 +29381,12 @@ export declare function validateDiagramSchema(schema: DiagramSchema): {
     errors: string[];
 };
 
+/**
+ * Validate a component documentation object.
+ * Returns array of validation errors (empty if valid).
+ */
+export declare function validateDoc(doc: unknown): string[];
+
 /**
  * Validate form schema
  */
@@ -25885,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
  */