@nice2dev/ui-enterprise 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,927 @@
+import { default as default_2 } from 'react';
+import { NiceBaseProps } from '@nice2dev/ui';
+import { ReactNode } from 'react';
+
+export declare type AccessEventType = 'login_success' | 'login_failed' | 'logout' | 'password_change' | 'password_reset' | 'mfa_enabled' | 'mfa_disabled' | 'mfa_challenged' | 'permission_change' | 'session_expired' | 'account_locked' | 'account_unlocked' | 'api_key_created' | 'api_key_revoked' | 'token_refresh' | 'suspicious_activity';
+
+export declare interface AccessLogEntry {
+    id: string;
+    timestamp: Date | string;
+    userId: string;
+    userName?: string;
+    userEmail?: string;
+    eventType: AccessEventType;
+    ipAddress: string;
+    location?: GeoLocation;
+    device?: DeviceInfo;
+    riskScore: number;
+    riskLevel: RiskLevel;
+    success: boolean;
+    details?: Record<string, unknown>;
+    flags?: string[];
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface AccessLogFilter {
+    startDate?: Date | string;
+    endDate?: Date | string;
+    eventTypes?: AccessEventType[];
+    riskLevels?: RiskLevel[];
+    userId?: string;
+    ipAddress?: string;
+    country?: string;
+    searchQuery?: string;
+    successOnly?: boolean;
+    failedOnly?: boolean;
+}
+
+export declare interface AccessLogLabels {
+    title?: string;
+    filters?: string;
+    search?: string;
+    export?: string;
+    refresh?: string;
+    details?: string;
+    stats?: string;
+    map?: string;
+    timeline?: string;
+    showMore?: string;
+    noResults?: string;
+    eventTypes?: Record<AccessEventType, string>;
+    riskLevels?: Record<RiskLevel, string>;
+    deviceTypes?: Record<DeviceType, string>;
+    columns?: {
+        timestamp?: string;
+        user?: string;
+        event?: string;
+        ip?: string;
+        location?: string;
+        device?: string;
+        risk?: string;
+        status?: string;
+    };
+}
+
+export declare interface AccessLogStats {
+    totalEvents: number;
+    successfulLogins: number;
+    failedLogins: number;
+    uniqueIPs: number;
+    uniqueCountries: number;
+    highRiskEvents: number;
+    suspiciousActivities: number;
+    activeSessionCount?: number;
+}
+
+export declare type ApprovalStatus = 'draft' | 'pending_review' | 'approved' | 'rejected' | 'signed';
+
+export declare interface ApprovalStep {
+    id: string;
+    name: string;
+    approvers: Approver[];
+    required: boolean;
+    order: number;
+    status: 'pending' | 'approved' | 'rejected';
+    completedAt?: Date;
+    completedBy?: string;
+    comments?: string;
+}
+
+export declare interface ApprovalWorkflow {
+    id: string;
+    currentStep: number;
+    steps: ApprovalStep[];
+    status: ApprovalStatus;
+}
+
+export declare interface Approver {
+    id: string;
+    name: string;
+    email: string;
+    role: string;
+    avatar?: string;
+}
+
+export declare type AuditAction = 'create' | 'update' | 'delete' | 'view' | 'export' | 'import' | 'approve' | 'reject' | 'login' | 'logout' | 'permission_change' | 'config_change' | 'custom';
+
+export declare interface AuditChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    displayOldValue?: string;
+    displayNewValue?: string;
+}
+
+export declare interface AuditDataSource {
+    fetchEntries(filter: AuditFilter, pagination: {
+        page: number;
+        pageSize: number;
+    }): Promise<{
+        entries: AuditEntry[];
+        totalCount: number;
+    }>;
+    getAvailableFilters?(): Promise<{
+        users: {
+            id: string;
+            name: string;
+        }[];
+        entityTypes: string[];
+        actions: AuditAction[];
+    }>;
+}
+
+export declare interface AuditEntry {
+    id: string;
+    timestamp: Date;
+    action: AuditAction;
+    actionLabel?: string;
+    severity?: AuditSeverity;
+    userId: string;
+    userName: string;
+    userEmail?: string;
+    userRole?: string;
+    userAvatar?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    location?: string;
+    entityType: string;
+    entityId: string;
+    entityName?: string;
+    changes?: AuditChange[];
+    metadata?: Record<string, unknown>;
+    notes?: string;
+    /** For grouping related actions */
+    transactionId?: string;
+}
+
+export declare interface AuditFilter {
+    startDate?: Date;
+    endDate?: Date;
+    actions?: AuditAction[];
+    userIds?: string[];
+    entityTypes?: string[];
+    entityIds?: string[];
+    severity?: AuditSeverity[];
+    searchQuery?: string;
+}
+
+export declare type AuditSeverity = 'info' | 'warning' | 'critical';
+
+export declare type ClauseCategory = 'general' | 'liability' | 'payment' | 'termination' | 'confidentiality' | 'compliance' | 'custom';
+
+export declare interface ClauseVariable {
+    name: string;
+    placeholder: string;
+    type: 'text' | 'number' | 'date' | 'currency' | 'select';
+    required?: boolean;
+    defaultValue?: string;
+    options?: string[];
+    validation?: string;
+}
+
+export declare type ConsentAction = 'accept_all' | 'reject_all' | 'custom' | 'save_preferences';
+
+export declare type ConsentCategory = 'necessary' | 'analytics' | 'marketing' | 'preferences' | 'social';
+
+export declare interface ConsentLabels {
+    title: string;
+    description: string;
+    acceptAll: string;
+    rejectAll: string;
+    customize: string;
+    savePreferences: string;
+    necessary: string;
+    analytics: string;
+    marketing: string;
+    preferences: string;
+    social: string;
+    dataRights: string;
+    exportData: string;
+    deleteData: string;
+    pending: string;
+    processing: string;
+    completed: string;
+    close: string;
+}
+
+export declare interface ConsentOption {
+    id: ConsentCategory;
+    label: string;
+    description: string;
+    required?: boolean;
+    enabled: boolean;
+    cookies?: string[];
+    partners?: string[];
+}
+
+export declare interface ConsentState {
+    version: string;
+    timestamp: Date;
+    categories: Record<ConsentCategory, boolean>;
+    action: ConsentAction;
+    ipAddress?: string;
+    userAgent?: string;
+}
+
+export declare interface ContractClause {
+    id: string;
+    name: string;
+    content: string;
+    category: ClauseCategory;
+    description?: string;
+    variables?: ClauseVariable[];
+    isRequired?: boolean;
+    order?: number;
+    version?: string;
+    lastModified?: Date;
+}
+
+export declare interface ContractComment {
+    id: string;
+    clauseId: string;
+    userId: string;
+    userName: string;
+    userAvatar?: string;
+    content: string;
+    createdAt: Date;
+    resolved?: boolean;
+    replies?: ContractComment[];
+}
+
+export declare interface ContractDocument {
+    id: string;
+    title: string;
+    type: string;
+    sections: ContractSection[];
+    variables: Record<string, string>;
+    status: ApprovalStatus;
+    workflow?: ApprovalWorkflow;
+    versions: ContractVersion[];
+    comments: ContractComment[];
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+}
+
+export declare interface ContractSection {
+    id: string;
+    title: string;
+    clauses: ContractClause[];
+    collapsed?: boolean;
+}
+
+export declare interface ContractVersion {
+    id: string;
+    version: string;
+    createdAt: Date;
+    createdBy: string;
+    changes: string;
+    snapshot?: string;
+}
+
+export declare interface DataExportRequest {
+    id: string;
+    type: DataRequestType;
+    status: 'pending' | 'processing' | 'completed' | 'rejected';
+    requestedAt: Date;
+    completedAt?: Date;
+    downloadUrl?: string;
+    description: string;
+}
+
+export declare type DataRequestType = 'export' | 'delete' | 'rectify' | 'restrict';
+
+export declare interface DataRetentionPolicy {
+    category: string;
+    description: string;
+    retentionDays: number;
+    legalBasis: string;
+    canDelete: boolean;
+}
+
+export declare interface DeviceInfo {
+    type: DeviceType;
+    os?: string;
+    osVersion?: string;
+    browser?: string;
+    browserVersion?: string;
+    fingerprint?: string;
+    isTrusted?: boolean;
+}
+
+export declare type DeviceType = 'desktop' | 'mobile' | 'tablet' | 'unknown';
+
+export declare interface ExportDataSource<T = unknown> {
+    /** Fetch data to export */
+    fetchData(options: {
+        fields: ExportField[];
+        filters?: Record<string, unknown>;
+        sorting?: {
+            field: string;
+            direction: 'asc' | 'desc';
+        }[];
+    }): Promise<T[]>;
+    /** Get total count (for progress) */
+    getCount?(filters?: Record<string, unknown>): Promise<number>;
+    /** Get available fields */
+    getFields(): ExportField[];
+}
+
+export declare interface ExportField {
+    field: string;
+    label: string;
+    include: boolean;
+    format?: string;
+    transform?: (value: unknown) => unknown;
+}
+
+export declare type ExportFormat = 'csv' | 'xlsx' | 'json' | 'pdf' | 'xml';
+
+export declare interface ExportJob {
+    id: string;
+    name: string;
+    templateId?: string;
+    format: ExportFormat;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    progress: number;
+    createdAt: Date;
+    completedAt?: Date;
+    downloadUrl?: string;
+    error?: string;
+    rowCount?: number;
+    fileSize?: number;
+}
+
+export declare interface ExportOptions {
+    /** Include headers */
+    includeHeaders?: boolean;
+    /** Date format */
+    dateFormat?: string;
+    /** Number format */
+    numberFormat?: string;
+    /** Delimiter for CSV */
+    csvDelimiter?: string;
+    /** Encoding */
+    encoding?: 'utf-8' | 'utf-16' | 'iso-8859-1';
+    /** Compression */
+    compress?: boolean;
+    /** Password protection (XLSX, PDF) */
+    password?: string;
+}
+
+export declare interface ExportTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    format: ExportFormat;
+    fields: ExportField[];
+    filters?: Record<string, unknown>;
+    sorting?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    options?: ExportOptions;
+}
+
+export declare interface GeoLocation {
+    country: string;
+    countryCode?: string;
+    city?: string;
+    region?: string;
+    latitude?: number;
+    longitude?: number;
+    timezone?: string;
+}
+
+export declare interface InvoiceData {
+    invoiceNumber?: string;
+    date?: string;
+    dueDate?: string;
+    seller?: {
+        name: string;
+        address?: string;
+        taxId?: string;
+        email?: string;
+        phone?: string;
+        logo?: string;
+    };
+    buyer?: {
+        name: string;
+        address?: string;
+        taxId?: string;
+        email?: string;
+    };
+    items?: InvoiceLineItem[];
+    subtotal?: number;
+    taxAmount?: number;
+    discount?: number;
+    total?: number;
+    currency?: string;
+    notes?: string;
+    terms?: string;
+    bankDetails?: {
+        bankName?: string;
+        accountNumber?: string;
+        iban?: string;
+        swift?: string;
+    };
+    customFields?: Record<string, string | number>;
+}
+
+export declare interface InvoiceDesignerLabels {
+    title?: string;
+    templates?: string;
+    elements?: string;
+    properties?: string;
+    preview?: string;
+    export?: string;
+    save?: string;
+    addElement?: string;
+    deleteElement?: string;
+    duplicateElement?: string;
+    lockElement?: string;
+    unlockElement?: string;
+    undo?: string;
+    redo?: string;
+    zoom?: string;
+    grid?: string;
+    snap?: string;
+    noSelection?: string;
+    lineItems?: string;
+    addLineItem?: string;
+    removeLineItem?: string;
+}
+
+export declare interface InvoiceElement {
+    id: string;
+    type: InvoiceElementType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    content?: string;
+    field?: string;
+    style?: Record<string, string | number>;
+    locked?: boolean;
+}
+
+export declare type InvoiceElementType = 'text' | 'field' | 'image' | 'table' | 'divider' | 'qrcode' | 'barcode' | 'signature' | 'total' | 'subtotal' | 'tax' | 'shape';
+
+export declare type InvoiceLineItem = {
+    id: string;
+    description: string;
+    quantity: number;
+    unitPrice: number;
+    discount?: number;
+    tax?: number;
+    total: number;
+};
+
+export declare interface InvoiceTemplate {
+    id: string;
+    name: string;
+    thumbnail?: string;
+    category: 'standard' | 'professional' | 'minimal' | 'modern' | 'custom';
+    elements: InvoiceElement[];
+    pageSize: 'a4' | 'letter' | 'legal';
+    orientation: 'portrait' | 'landscape';
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+
+export declare const NiceAccessLog: default_2.ForwardRefExoticComponent<NiceAccessLogProps & default_2.RefAttributes<NiceAccessLogRef>>;
+
+export declare interface NiceAccessLogProps extends NiceBaseProps {
+    /** Log entries data */
+    entries: AccessLogEntry[];
+    /** Initial filter */
+    filter?: AccessLogFilter;
+    /** Statistics */
+    stats?: AccessLogStats;
+    /** Enable real-time updates */
+    realtime?: boolean;
+    /** Polling interval in ms for real-time */
+    pollingInterval?: number;
+    /** Show geo map visualization */
+    showMap?: boolean;
+    /** Show statistics panel */
+    showStats?: boolean;
+    /** Enable entry detail view */
+    showDetails?: boolean;
+    /** Page size for pagination */
+    pageSize?: number;
+    /** Custom labels */
+    labels?: AccessLogLabels;
+    /** Loading state */
+    loading?: boolean;
+    /** Called when filter changes */
+    onFilterChange?: (filter: AccessLogFilter) => void;
+    /** Called when export requested */
+    onExport?: (format: 'csv' | 'json' | 'pdf') => void;
+    /** Called when entry selected */
+    onEntrySelect?: (entry: AccessLogEntry) => void;
+    /** Called when block IP requested */
+    onBlockIP?: (ip: string) => void;
+    /** Called when refresh requested */
+    onRefresh?: () => void;
+}
+
+export declare interface NiceAccessLogRef {
+    /** Get current filter */
+    getFilter: () => AccessLogFilter;
+    /** Apply filter */
+    applyFilter: (filter: AccessLogFilter) => void;
+    /** Clear all filters */
+    clearFilters: () => void;
+    /** Export data */
+    export: (format: 'csv' | 'json' | 'pdf') => void;
+    /** Refresh data */
+    refresh: () => void;
+    /** Get selected entry */
+    getSelectedEntry: () => AccessLogEntry | null;
+    /** Get container element */
+    getElement: () => HTMLDivElement | null;
+}
+
+export declare const NiceAuditTrail: default_2.ForwardRefExoticComponent<NiceAuditTrailProps & default_2.RefAttributes<NiceAuditTrailRef>>;
+
+export declare interface NiceAuditTrailProps extends NiceBaseProps {
+    /** Data source */
+    dataSource: AuditDataSource;
+    /** Initial filter */
+    initialFilter?: AuditFilter;
+    /** Page size */
+    pageSize?: number;
+    /** View mode */
+    viewMode?: 'table' | 'timeline';
+    /** Enable export */
+    enableExport?: boolean;
+    /** Enable diff viewer */
+    showDiffs?: boolean;
+    /** Render custom action icon */
+    renderActionIcon?: (action: AuditAction) => ReactNode;
+    /** Render custom user */
+    renderUser?: (entry: AuditEntry) => ReactNode;
+    /** Called when entry is clicked */
+    onEntryClick?: (entry: AuditEntry) => void;
+    /** Called on export */
+    onExport?: (entries: AuditEntry[], format: 'csv' | 'json') => void;
+    /** Title */
+    title?: string;
+}
+
+export declare interface NiceAuditTrailRef {
+    refresh: () => Promise<void>;
+    setFilter: (filter: AuditFilter) => void;
+    getEntries: () => AuditEntry[];
+}
+
+export declare const NiceContractEditor: default_2.ForwardRefExoticComponent<NiceContractEditorProps & default_2.RefAttributes<NiceContractEditorRef>>;
+
+export declare interface NiceContractEditorProps extends NiceBaseProps {
+    /** Document to edit */
+    document: ContractDocument;
+    /** Available clause library */
+    clauseLibrary?: ContractClause[];
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Show clause library panel */
+    showClauseLibrary?: boolean;
+    /** Show version history */
+    showVersionHistory?: boolean;
+    /** Show comments panel */
+    showComments?: boolean;
+    /** Show approval workflow */
+    showWorkflow?: boolean;
+    /** Current user (for comments) */
+    currentUser?: {
+        id: string;
+        name: string;
+        avatar?: string;
+    };
+    /** Called when document changes */
+    onChange?: (document: ContractDocument) => void;
+    /** Called when clause is added */
+    onAddClause?: (clause: ContractClause, sectionId: string) => void;
+    /** Called when clause is removed */
+    onRemoveClause?: (clauseId: string, sectionId: string) => void;
+    /** Called when variable changes */
+    onVariableChange?: (name: string, value: string) => void;
+    /** Called when comment is added */
+    onAddComment?: (comment: ContractComment) => void;
+    /** Called when approval action */
+    onApprovalAction?: (stepId: string, action: 'approve' | 'reject', comments?: string) => void;
+    /** Called on version restore */
+    onRestoreVersion?: (versionId: string) => void;
+    /** Called on save */
+    onSave?: (document: ContractDocument) => void;
+    /** Called on export */
+    onExport?: (format: 'pdf' | 'docx' | 'html') => void;
+}
+
+export declare interface NiceContractEditorRef {
+    getDocument: () => ContractDocument;
+    insertClause: (clause: ContractClause, sectionId: string) => void;
+    setVariable: (name: string, value: string) => void;
+    exportDocument: (format: 'pdf' | 'docx' | 'html') => void;
+    validate: () => {
+        valid: boolean;
+        errors: string[];
+    };
+}
+
+export declare const NiceDataExportCenter: default_2.ForwardRefExoticComponent<NiceDataExportCenterProps & default_2.RefAttributes<NiceDataExportCenterRef>>;
+
+export declare interface NiceDataExportCenterProps extends NiceBaseProps {
+    /** Data source */
+    dataSource: ExportDataSource;
+    /** Available export formats */
+    formats?: ExportFormat[];
+    /** Saved templates */
+    templates?: ExportTemplate[];
+    /** Enable scheduling */
+    enableScheduling?: boolean;
+    /** Export history */
+    exportHistory?: ExportJob[];
+    /** Called when export starts */
+    onExportStart?: (job: ExportJob) => void;
+    /** Called when export completes */
+    onExportComplete?: (job: ExportJob) => void;
+    /** Called when export fails */
+    onExportError?: (job: ExportJob, error: Error) => void;
+    /** Called to save template */
+    onSaveTemplate?: (template: ExportTemplate) => void;
+    /** Called to delete template */
+    onDeleteTemplate?: (templateId: string) => void;
+    /** Called to schedule export */
+    onSchedule?: (schedule: ScheduleConfig, template: ExportTemplate) => void;
+    /** Custom export handler (if you want to handle export server-side) */
+    customExportHandler?: (format: ExportFormat, data: unknown[], options: ExportOptions) => Promise<Blob | string>;
+    /** Title */
+    title?: string;
+    /** Description */
+    description?: string;
+}
+
+export declare interface NiceDataExportCenterRef {
+    exportNow: (format: ExportFormat) => Promise<void>;
+    getSelectedFields: () => ExportField[];
+    loadTemplate: (templateId: string) => void;
+}
+
+export declare const NiceGDPRConsent: default_2.ForwardRefExoticComponent<NiceGDPRConsentProps & default_2.RefAttributes<NiceGDPRConsentRef>>;
+
+export declare interface NiceGDPRConsentProps extends NiceBaseProps {
+    /** Application name */
+    appName: string;
+    /** Company name */
+    companyName: string;
+    /** Consent options */
+    options?: ConsentOption[];
+    /** Current consent state */
+    currentConsent?: ConsentState | null;
+    /** Data retention policies */
+    retentionPolicies?: DataRetentionPolicy[];
+    /** Previous data requests */
+    dataRequests?: DataExportRequest[];
+    /** Privacy policy sections */
+    privacyPolicy?: PrivacyPolicySection[];
+    /** Storage key for consent */
+    storageKey?: string;
+    /** Consent version (for re-prompting) */
+    consentVersion?: string;
+    /** Show as banner or modal */
+    variant?: 'banner' | 'modal' | 'embedded';
+    /** Banner position */
+    position?: 'top' | 'bottom';
+    /** Called when consent changes */
+    onConsentChange?: (consent: ConsentState) => void;
+    /** Called on data request */
+    onDataRequest?: (type: DataRequestType, reason?: string) => Promise<DataExportRequest>;
+    /** Called to download export */
+    onDownloadExport?: (requestId: string) => void;
+    /** Privacy policy URL */
+    privacyPolicyUrl?: string;
+    /** Cookie policy URL */
+    cookiePolicyUrl?: string;
+    /** Terms URL */
+    termsUrl?: string;
+    /** Labels (i18n) */
+    labels?: Partial<ConsentLabels>;
+}
+
+export declare interface NiceGDPRConsentRef {
+    showBanner: () => void;
+    hideBanner: () => void;
+    getConsent: () => ConsentState | null;
+    revokeConsent: () => void;
+    openPreferences: () => void;
+}
+
+export declare const NiceGlobalSearch: default_2.ForwardRefExoticComponent<NiceGlobalSearchProps & default_2.RefAttributes<NiceGlobalSearchRef>>;
+
+export declare interface NiceGlobalSearchProps extends NiceBaseProps {
+    /** Search sources */
+    sources: SearchSource[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum characters before search */
+    minQueryLength?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Show categories */
+    showCategories?: boolean;
+    /** Available filters */
+    filters?: SearchFilter[];
+    /** Show recent searches */
+    showRecent?: boolean;
+    /** Maximum recent searches */
+    maxRecent?: number;
+    /** Show keyboard shortcuts */
+    showShortcuts?: boolean;
+    /** Hotkey to open (e.g., 'k' for Cmd+K) */
+    hotkey?: string;
+    /** Called when result is selected */
+    onResultSelect?: (result: SearchResult) => void;
+    /** Called when search is performed */
+    onSearch?: (query: string, results: SearchResult[]) => void;
+    /** Called when closed */
+    onClose?: () => void;
+    /** Render custom result */
+    renderResult?: (result: SearchResult, isSelected: boolean) => ReactNode;
+    /** Render custom empty state */
+    renderEmpty?: (query: string) => ReactNode;
+    /** Initial open state */
+    defaultOpen?: boolean;
+    /** Controlled open state */
+    open?: boolean;
+    /** Variant */
+    variant?: 'modal' | 'inline' | 'dropdown';
+    /** Labels */
+    labels?: Partial<SearchLabels>;
+}
+
+export declare interface NiceGlobalSearchRef {
+    open: () => void;
+    close: () => void;
+    focus: () => void;
+    clear: () => void;
+    search: (query: string) => Promise<void>;
+}
+
+export declare const NiceInvoiceDesigner: default_2.ForwardRefExoticComponent<NiceInvoiceDesignerProps & default_2.RefAttributes<NiceInvoiceDesignerRef>>;
+
+export declare interface NiceInvoiceDesignerProps extends NiceBaseProps {
+    /** Initial template */
+    template?: InvoiceTemplate;
+    /** Invoice data for preview */
+    data?: InvoiceData;
+    /** Available templates library */
+    templates?: InvoiceTemplate[];
+    /** Available data fields for binding */
+    dataFields?: {
+        key: string;
+        label: string;
+        type: 'text' | 'number' | 'date' | 'currency';
+    }[];
+    /** Enable grid */
+    showGrid?: boolean;
+    /** Grid size in pixels */
+    gridSize?: number;
+    /** Enable snap to grid */
+    snapToGrid?: boolean;
+    /** Enable rulers */
+    showRulers?: boolean;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Custom labels */
+    labels?: InvoiceDesignerLabels;
+    /** Called when template changes */
+    onChange?: (template: InvoiceTemplate) => void;
+    /** Called when export is requested */
+    onExport?: (format: 'pdf' | 'png' | 'print') => void;
+    /** Called when template is saved */
+    onSave?: (template: InvoiceTemplate) => void;
+}
+
+export declare interface NiceInvoiceDesignerRef {
+    /** Get current template */
+    getTemplate: () => InvoiceTemplate;
+    /** Set template */
+    setTemplate: (template: InvoiceTemplate) => void;
+    /** Export invoice */
+    export: (format: 'pdf' | 'png' | 'print') => void;
+    /** Add element */
+    addElement: (type: InvoiceElementType) => void;
+    /** Remove selected element */
+    removeSelected: () => void;
+    /** Undo last action */
+    undo: () => void;
+    /** Redo last undone action */
+    redo: () => void;
+    /** Get container element */
+    getElement: () => HTMLDivElement | null;
+}
+
+export declare interface PrivacyPolicySection {
+    id: string;
+    title: string;
+    content: string;
+    lastUpdated?: Date;
+}
+
+export declare interface RecentSearch {
+    query: string;
+    timestamp: Date;
+    resultCount?: number;
+}
+
+export declare type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+
+export declare interface ScheduleConfig {
+    enabled: boolean;
+    frequency: 'daily' | 'weekly' | 'monthly' | 'custom';
+    time: string;
+    daysOfWeek?: number[];
+    dayOfMonth?: number;
+    cronExpression?: string;
+    deliveryMethod: 'download' | 'email' | 'sftp' | 'api';
+    recipients?: string[];
+    sftpConfig?: {
+        host: string;
+        path: string;
+        username: string;
+    };
+    apiEndpoint?: string;
+}
+
+export declare interface SearchAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    onClick: () => void;
+}
+
+export declare interface SearchCategory {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    count?: number;
+}
+
+export declare interface SearchFilter {
+    field: string;
+    label: string;
+    type: 'select' | 'multi-select' | 'date' | 'range';
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    value?: unknown;
+}
+
+export declare interface SearchLabels {
+    placeholder: string;
+    recent: string;
+    noResults: string;
+    searching: string;
+    clearRecent: string;
+    categories: string;
+    filters: string;
+}
+
+export declare interface SearchResult {
+    id: string;
+    type: SearchResultType;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    icon?: ReactNode;
+    image?: string;
+    url?: string;
+    relevanceScore: number;
+    source: string;
+    metadata?: Record<string, unknown>;
+    actions?: SearchAction[];
+    highlights?: {
+        field: string;
+        matches: string[];
+    }[];
+}
+
+export declare type SearchResultType = 'document' | 'user' | 'task' | 'project' | 'setting' | 'help' | 'action' | 'custom';
+
+export declare interface SearchSource {
+    id: string;
+    name: string;
+    icon?: ReactNode;
+    search: (query: string, filters?: Record<string, unknown>) => Promise<SearchResult[]>;
+    priority?: number;
+}
+
+export { }