import { default as default_2 } from 'react';

/** Admin notification template. */
export declare interface AdminNotification {
    id: string;
    name: string;
    description?: string;
    event: string;
    channels: NotificationChannel[];
    enabled: boolean;
    template?: string;
    lastSentAt?: string;
    sentCount?: number;
}

/** Role definition. */
export declare interface AdminRole {
    id: string;
    name: string;
    description?: string;
    color?: string;
    isSystem?: boolean;
    /** Map of resourceId → actionId[] granted. */
    permissions: Record<string, string[]>;
    userCount?: number;
}

/** Admin user entry. */
export declare interface AdminUser {
    id: string;
    name: string;
    email: string;
    avatarUrl?: string;
    roles: string[];
    status: 'active' | 'inactive' | 'suspended' | 'pending';
    createdAt: string;
    lastLoginAt?: string;
}

/** Dashboard widget definition. */
export declare interface AdminWidget {
    id: string;
    title: string;
    type: 'stat' | 'chart' | 'table' | 'list' | 'custom';
    /** Grid column span (1–4). */
    colSpan?: number;
    /** Grid row span. */
    rowSpan?: number;
    /** Widget value for stat type. */
    value?: string | number;
    /** Change indicator (e.g. "+12%"). */
    change?: string;
    /** Whether change is positive. */
    changePositive?: boolean;
    /** Icon/emoji. */
    icon?: string;
    /** Custom render function. */
    render?: () => default_2.ReactNode;
}

/** Audit log entry. */
export declare interface AuditLogEntry {
    id: string;
    timestamp: string;
    actorName: string;
    actorId?: string;
    action: string;
    resource: string;
    resourceId?: string;
    severity: AuditSeverity;
    details?: string;
    ipAddress?: string;
    metadata?: Record<string, unknown>;
}

/** Audit log severity. */
export declare type AuditSeverity = 'info' | 'warning' | 'error' | 'critical';

/** Column mapping for import. */
export declare interface ColumnMapping {
    sourceColumn: string;
    targetField: string;
    transform?: string;
}

/** Supported import/export format. */
export declare type DataFormat = 'json' | 'csv' | 'xlsx' | 'xml' | 'yaml';

/** Feature flag definition. */
export declare interface FeatureFlag {
    id: string;
    key: string;
    name: string;
    description?: string;
    environments: FlagEnvironment[];
    createdAt: string;
    updatedAt?: string;
    tags?: string[];
}

/**
 * Declarative feature gate component.
 *
 * @example
 * ```tsx
 * <FeatureGate flag="beta-ui" fallback={<OldUI />}>
 *   <NewUI />
 * </FeatureGate>
 * ```
 */
declare function FeatureGate({ flag, fallback, children }: FeatureGateProps): default_2.JSX.Element;
export { FeatureGate }
export { FeatureGate as NiceFeatureGate }

/** Configuration for the feature gate provider. */
export declare interface FeatureGateConfig {
    /** Map of flag key → enabled status (or percentage 0–100). */
    flags: Record<string, boolean | number>;
    /** Current environment name (e.g. 'production'). */
    environment?: string;
}

/** Props for {@link FeatureGate}. */
export declare interface FeatureGateProps {
    /** Feature flag key to check. */
    flag: string;
    /** Content to render when the flag is disabled. */
    fallback?: default_2.ReactNode;
    children: default_2.ReactNode;
}

/** Result returned by {@link useFeatureGate}. */
export declare interface FeatureGateResult {
    /** Whether the feature is enabled. */
    enabled: boolean;
    /** Rollout percentage (0–100), if applicable. */
    percentage?: number;
}

/** Feature flag environment. */
export declare interface FlagEnvironment {
    name: string;
    enabled: boolean;
    percentage?: number;
}

/** Honey token definition. */
export declare interface HoneyToken {
    id: string;
    name: string;
    type: HoneyTokenType;
    severity: HoneyTokenSeverity;
    location: string;
    active: boolean;
    tripCount: number;
    lastTripped?: string;
    createdAt: string;
}

/** A single honey token trip event. */
export declare interface HoneyTokenEvent {
    id: string;
    tokenId: string;
    tokenName: string;
    type: HoneyTokenType;
    severity: HoneyTokenSeverity;
    sourceIp: string;
    userAgent?: string;
    userId?: string;
    timestamp: string;
    details?: string;
}

/** Honey token severity level. */
export declare type HoneyTokenSeverity = 'low' | 'medium' | 'high' | 'critical';

/** Honey token type. */
export declare type HoneyTokenType = 'field' | 'endpoint' | 'file' | 'credential' | 'cookie';

/** Import/export job status. */
export declare interface ImportExportJob {
    id: string;
    type: 'import' | 'export';
    format: DataFormat;
    status: 'pending' | 'running' | 'completed' | 'failed';
    fileName?: string;
    totalRows?: number;
    processedRows?: number;
    errorCount?: number;
    createdAt: string;
    completedAt?: string;
    errorMessage?: string;
}

/**
 * {@link NiceAdminAuditLog} — Audit log viewer with search and severity filtering.
 */
export declare const NiceAdminAuditLog: default_2.ForwardRefExoticComponent<NiceAdminAuditLogProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminAuditLog}. */
export declare interface NiceAdminAuditLogProps {
    /** Log entries. */
    entries: AuditLogEntry[];
    /** Called when an entry is clicked for details. */
    onEntryClick?: (entry: AuditLogEntry) => void;
    /** Called when requesting more entries. */
    onLoadMore?: () => void;
    /** Whether more entries are available. */
    hasMore?: boolean;
    /** Whether to show search. */
    searchable?: boolean;
    /** Whether to show severity filter. */
    showSeverityFilter?: boolean;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceAdminDashboard} — Admin dashboard with configurable widget grid.
 */
export declare const NiceAdminDashboard: default_2.ForwardRefExoticComponent<NiceAdminDashboardProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminDashboard}. */
export declare interface NiceAdminDashboardProps {
    /** Dashboard widgets. */
    widgets: AdminWidget[];
    /** Number of grid columns (default 4). */
    columns?: number;
    /** Title. */
    title?: string;
    /** Header action buttons. */
    headerActions?: default_2.ReactNode;
    /** Called when a widget is clicked. */
    onWidgetClick?: (widget: AdminWidget) => void;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceAdminNotifications} — Notification management panel.
 */
export declare const NiceAdminNotifications: default_2.ForwardRefExoticComponent<NiceAdminNotificationsProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminNotifications}. */
export declare interface NiceAdminNotificationsProps {
    /** Notification definitions. */
    notifications: AdminNotification[];
    /** Available channels. */
    availableChannels?: NotificationChannel[];
    /** Called when toggling enabled. */
    onToggle?: (id: string, enabled: boolean) => void;
    /** Called when editing a notification. */
    onEdit?: (notification: AdminNotification) => void;
    /** Called when testing a notification. */
    onTest?: (id: string) => void;
    /** Called when creating a notification. */
    onCreate?: () => void;
    /** Called when deleting a notification. */
    onDelete?: (id: string) => void;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceAdminRoles} — Role management with permission matrix grid.
 */
export declare const NiceAdminRoles: default_2.ForwardRefExoticComponent<NiceAdminRolesProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminRoles}. */
export declare interface NiceAdminRolesProps {
    /** Roles. */
    roles: AdminRole[];
    /** Available permission actions. */
    actions: PermissionAction[];
    /** Available permission resources. */
    resources: PermissionResource[];
    /** Called when role permissions change. */
    onPermissionChange?: (roleId: string, resourceId: string, actionId: string, granted: boolean) => void;
    /** Called when creating a role. */
    onCreate?: (name: string, description: string) => void;
    /** Called when deleting a role. */
    onDelete?: (roleId: string) => void;
    /** Called when renaming a role. */
    onRename?: (roleId: string, name: string) => void;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceAdminSettings} — System settings editor with sections and validation.
 */
export declare const NiceAdminSettings: default_2.ForwardRefExoticComponent<NiceAdminSettingsProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminSettings}. */
export declare interface NiceAdminSettingsProps {
    /** Settings items. */
    settings: SettingItem[];
    /** Called when saving. */
    onSave?: (values: Record<string, unknown>) => void;
    /** Called when a single setting changes. */
    onChange?: (key: string, value: unknown) => void;
    /** Called to reset to defaults. */
    onReset?: () => void;
    /** Whether save button is loading. */
    saving?: boolean;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceAdminUsers} — User management table with CRUD and role assignment.
 */
export declare const NiceAdminUsers: default_2.ForwardRefExoticComponent<NiceAdminUsersProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceAdminUsers}. */
export declare interface NiceAdminUsersProps {
    /** Users to display. */
    users: AdminUser[];
    /** Available roles for assignment. */
    availableRoles?: string[];
    /** Called when creating a user. */
    onCreate?: () => void;
    /** Called when editing a user. */
    onEdit?: (user: AdminUser) => void;
    /** Called when deleting a user. */
    onDelete?: (userId: string) => void;
    /** Called when toggling user status. */
    onToggleStatus?: (userId: string, status: AdminUser['status']) => void;
    /** Called when changing user roles. */
    onChangeRoles?: (userId: string, roles: string[]) => void;
    /** Whether to show search. */
    searchable?: boolean;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceFeatureFlags} — Feature flag management with environment toggles and rollout percentages.
 */
export declare const NiceFeatureFlags: default_2.ForwardRefExoticComponent<NiceFeatureFlagsProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceFeatureFlags}. */
export declare interface NiceFeatureFlagsProps {
    /** Feature flags. */
    flags: FeatureFlag[];
    /** Available environment names. */
    environmentNames?: string[];
    /** Called when toggling a flag in an environment. */
    onToggle?: (flagId: string, envName: string, enabled: boolean) => void;
    /** Called when changing rollout percentage. */
    onPercentageChange?: (flagId: string, envName: string, percentage: number) => void;
    /** Called when creating a new flag. */
    onCreate?: (key: string, name: string, description: string) => void;
    /** Called when deleting a flag. */
    onDelete?: (flagId: string) => void;
    /** Called when editing a flag. */
    onEdit?: (flag: FeatureFlag) => void;
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/** Provides feature flag configuration to descendant components. */
export declare function NiceFeatureGateProvider({ config, children }: NiceFeatureGateProviderProps): default_2.JSX.Element;

/** Props for {@link NiceFeatureGateProvider}. */
export declare interface NiceFeatureGateProviderProps {
    /** Feature gate configuration. */
    config: FeatureGateConfig;
    children: default_2.ReactNode;
}

/** Dashboard for monitoring honey tokens (deceptive security traps). */
export declare const NiceHoneyTokenDashboard: default_2.ForwardRefExoticComponent<NiceHoneyTokenDashboardProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceHoneyTokenDashboard}. */
export declare interface NiceHoneyTokenDashboardProps {
    /** Configured honey tokens. */
    tokens: HoneyToken[];
    /** Recent trip events. */
    events: HoneyTokenEvent[];
    /** Called when creating a new honey token. */
    onCreate?: (name: string, type: HoneyTokenType, severity: HoneyTokenSeverity, location: string) => void;
    /** Called when toggling a honey token on/off. */
    onToggle?: (tokenId: string, active: boolean) => void;
    /** Called when deleting a honey token. */
    onDelete?: (tokenId: string) => void;
    /** Called when dismissing an event. */
    onDismissEvent?: (eventId: string) => void;
    /** Panel title. */
    title?: string;
    /** Additional CSS class. */
    className?: string;
    /** Inline styles. */
    style?: default_2.CSSProperties;
}

/**
 * {@link NiceImportExport} — Data import/export with format selection, file upload, and job tracking.
 */
export declare const NiceImportExport: default_2.ForwardRefExoticComponent<NiceImportExportProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for {@link NiceImportExport}. */
export declare interface NiceImportExportProps {
    /** Available target entities (e.g. "users", "products"). */
    entities: Array<{
        id: string;
        label: string;
    }>;
    /** Available formats. */
    formats?: DataFormat[];
    /** Recent jobs. */
    jobs?: ImportExportJob[];
    /** Called when starting an import. */
    onImport?: (entityId: string, format: DataFormat, file: File, mappings?: ColumnMapping[]) => void;
    /** Called when starting an export. */
    onExport?: (entityId: string, format: DataFormat) => void;
    /** Called when downloading a completed export. */
    onDownload?: (jobId: string) => void;
    /** Available target fields for mapping. */
    targetFields?: string[];
    /** Title. */
    title?: string;
    className?: string;
    style?: default_2.CSSProperties;
}

/** Notification channel. */
export declare type NotificationChannel = 'email' | 'push' | 'sms' | 'in-app' | 'webhook';

/** Permission action. */
export declare interface PermissionAction {
    id: string;
    label: string;
    description?: string;
}

/** Permission resource. */
export declare interface PermissionResource {
    id: string;
    label: string;
    category?: string;
}

/** A single setting item. */
export declare interface SettingItem {
    key: string;
    label: string;
    description?: string;
    type: SettingType;
    value: unknown;
    options?: Array<{
        value: string;
        label: string;
    }>;
    required?: boolean;
    section?: string;
    placeholder?: string;
}

/** Setting value type. */
export declare type SettingType = 'text' | 'number' | 'boolean' | 'select' | 'textarea' | 'color' | 'password';

/**
 * Runtime hook for conditional rendering based on feature flags.
 *
 * @param flag - The feature flag key to check.
 * @returns `{ enabled, percentage }` for the given flag.
 *
 * @example
 * ```tsx
 * const { enabled } = useFeatureGate('new-dashboard');
 * if (!enabled) return null;
 * return <NewDashboard />;
 * ```
 */
export declare function useFeatureGate(flag: string): FeatureGateResult;

export { }