@tidecloak/ui-framework 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,2739 @@
+export { QueryClient, QueryClientConfig, QueryClientProvider, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import React$1, { ReactNode } from 'react';
+import { ClassValue } from 'clsx';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Theme constants for consistent styling across components.
+ * Use CSS variables for runtime theming, constants for TypeScript type safety.
+ */
+declare const colors: {
+    readonly background: {
+        readonly primary: "var(--tc-bg-primary, #ffffff)";
+        readonly secondary: "var(--tc-bg-secondary, #f9fafb)";
+        readonly muted: "var(--tc-bg-muted, #f3f4f6)";
+        readonly overlay: "var(--tc-bg-overlay, rgba(0, 0, 0, 0.5))";
+    };
+    readonly foreground: {
+        readonly primary: "var(--tc-fg-primary, #111827)";
+        readonly secondary: "var(--tc-fg-secondary, #374151)";
+        readonly muted: "var(--tc-fg-muted, #6b7280)";
+        readonly disabled: "var(--tc-fg-disabled, #9ca3af)";
+    };
+    readonly border: {
+        readonly default: "var(--tc-border, #e5e7eb)";
+        readonly focus: "var(--tc-border-focus, #3b82f6)";
+        readonly error: "var(--tc-border-error, #dc2626)";
+    };
+    readonly status: {
+        readonly success: "var(--tc-success, #16a34a)";
+        readonly successBg: "var(--tc-success-bg, #dcfce7)";
+        readonly error: "var(--tc-error, #dc2626)";
+        readonly errorBg: "var(--tc-error-bg, #fef2f2)";
+        readonly warning: "var(--tc-warning, #f59e0b)";
+        readonly warningBg: "var(--tc-warning-bg, #fef3c7)";
+        readonly info: "var(--tc-info, #3b82f6)";
+        readonly infoBg: "var(--tc-info-bg, #eff6ff)";
+        readonly pending: "var(--tc-pending, #6b7280)";
+        readonly pendingBg: "var(--tc-pending-bg, #f3f4f6)";
+    };
+    readonly action: {
+        readonly primary: "var(--tc-action-primary, #3b82f6)";
+        readonly primaryHover: "var(--tc-action-primary-hover, #2563eb)";
+        readonly danger: "var(--tc-action-danger, #dc2626)";
+        readonly dangerHover: "var(--tc-action-danger-hover, #b91c1c)";
+    };
+};
+declare const spacing: {
+    readonly xs: "0.25rem";
+    readonly sm: "0.5rem";
+    readonly md: "1rem";
+    readonly lg: "1.5rem";
+    readonly xl: "2rem";
+    readonly "2xl": "3rem";
+};
+declare const radius: {
+    readonly sm: "0.25rem";
+    readonly md: "0.375rem";
+    readonly lg: "0.5rem";
+    readonly full: "9999px";
+};
+declare const fontSize: {
+    readonly xs: "0.75rem";
+    readonly sm: "0.875rem";
+    readonly base: "1rem";
+    readonly lg: "1.125rem";
+    readonly xl: "1.25rem";
+    readonly "2xl": "1.5rem";
+};
+declare const zIndex: {
+    readonly dropdown: 50;
+    readonly sticky: 100;
+    readonly modal: 200;
+    readonly overlay: 300;
+    readonly toast: 400;
+};
+declare const duration: {
+    readonly fast: "150ms";
+    readonly normal: "200ms";
+    readonly slow: "300ms";
+};
+declare const focusRing: {
+    readonly outline: "2px solid var(--tc-border-focus, #3b82f6)";
+    readonly outlineOffset: "2px";
+};
+declare const shadow: {
+    readonly sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)";
+    readonly md: "0 4px 6px -1px rgba(0, 0, 0, 0.1)";
+    readonly lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1)";
+};
+declare const themeCSS = "\n  :root {\n    --tc-bg-primary: #ffffff;\n    --tc-bg-secondary: #f9fafb;\n    --tc-bg-muted: #f3f4f6;\n    --tc-bg-overlay: rgba(0, 0, 0, 0.5);\n    --tc-fg-primary: #111827;\n    --tc-fg-secondary: #374151;\n    --tc-fg-muted: #6b7280;\n    --tc-fg-disabled: #9ca3af;\n    --tc-border: #e5e7eb;\n    --tc-border-focus: #3b82f6;\n    --tc-border-error: #dc2626;\n    --tc-success: #16a34a;\n    --tc-success-bg: #dcfce7;\n    --tc-error: #dc2626;\n    --tc-error-bg: #fef2f2;\n    --tc-warning: #f59e0b;\n    --tc-warning-bg: #fef3c7;\n    --tc-info: #3b82f6;\n    --tc-info-bg: #eff6ff;\n    --tc-pending: #6b7280;\n    --tc-pending-bg: #f3f4f6;\n    --tc-action-primary: #3b82f6;\n    --tc-action-primary-hover: #2563eb;\n    --tc-action-danger: #dc2626;\n    --tc-action-danger-hover: #b91c1c;\n  }\n\n  @media (prefers-color-scheme: dark) {\n    :root {\n      --tc-bg-primary: #1f2937;\n      --tc-bg-secondary: #111827;\n      --tc-bg-muted: #374151;\n      --tc-bg-overlay: rgba(0, 0, 0, 0.7);\n      --tc-fg-primary: #f9fafb;\n      --tc-fg-secondary: #e5e7eb;\n      --tc-fg-muted: #9ca3af;\n      --tc-fg-disabled: #6b7280;\n      --tc-border: #374151;\n      --tc-border-focus: #60a5fa;\n      --tc-border-error: #f87171;\n      --tc-success: #22c55e;\n      --tc-success-bg: #14532d;\n      --tc-error: #f87171;\n      --tc-error-bg: #7f1d1d;\n      --tc-warning: #fbbf24;\n      --tc-warning-bg: #78350f;\n      --tc-info: #60a5fa;\n      --tc-info-bg: #1e3a8a;\n      --tc-pending: #9ca3af;\n      --tc-pending-bg: #374151;\n      --tc-action-primary: #60a5fa;\n      --tc-action-primary-hover: #3b82f6;\n      --tc-action-danger: #f87171;\n      --tc-action-danger-hover: #dc2626;\n    }\n  }\n\n  @media (prefers-reduced-motion: reduce) {\n    *, *::before, *::after {\n      animation-duration: 0.01ms !important;\n      animation-iteration-count: 1 !important;\n      transition-duration: 0.01ms !important;\n    }\n  }\n";
+declare function injectThemeCSS(): void;
+
+/**
+ * Base interface for all data items - requires an id
+ */
+interface BaseDataItem {
+    id: string;
+}
+/**
+ * Generic change set request structure for approval workflows
+ */
+interface ChangeSetRequest {
+    changeSetId: string;
+    changeSetType: string;
+    actionType: string;
+}
+/**
+ * Base interface for items that can be approved
+ */
+interface ApprovableItem extends BaseDataItem {
+    status: string;
+    retrievalInfo?: ChangeSetRequest;
+}
+/**
+ * Column definition for data tables
+ * Note: T can be any type with the properties needed for rendering
+ */
+interface ColumnDef<T = any> {
+    /** Unique key for the column */
+    key: string;
+    /** Display header */
+    header: string | ReactNode;
+    /** Cell renderer */
+    cell: (item: T, index: number) => ReactNode;
+    /** Optional sorting key (if different from key) */
+    sortKey?: keyof T | string;
+    /** Enable sorting for this column */
+    sortable?: boolean;
+    /** Responsive visibility */
+    responsive?: "sm" | "md" | "lg" | "xl" | "always";
+    /** Column width class */
+    width?: string;
+    /** Alignment */
+    align?: "left" | "center" | "right";
+}
+/**
+ * Table action definition
+ */
+interface TableAction<T extends BaseDataItem> {
+    /** Action identifier */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Icon component */
+    icon?: ReactNode;
+    /** Action handler */
+    onClick: (item: T) => void | Promise<void>;
+    /** Visibility condition */
+    visible?: (item: T) => boolean;
+    /** Disabled condition */
+    disabled?: (item: T) => boolean;
+    /** Button variant */
+    variant?: "default" | "destructive" | "ghost" | "link" | "outline";
+    /** Color class */
+    colorClass?: string;
+}
+/**
+ * Bulk action definition for multi-select
+ */
+interface BulkAction<T extends BaseDataItem> {
+    key: string;
+    label: string;
+    icon?: ReactNode;
+    onClick: (items: T[]) => void | Promise<void>;
+    disabled?: (items: T[]) => boolean;
+    variant?: "default" | "destructive" | "ghost" | "outline";
+}
+/**
+ * Sort configuration
+ */
+interface SortConfig {
+    key: string;
+    direction: "asc" | "desc";
+}
+/**
+ * Pagination configuration
+ */
+interface PaginationConfig {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+}
+/**
+ * Tab definition
+ */
+interface TabDef {
+    /** Unique tab key */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Optional badge count */
+    badge?: number | null;
+    /** Badge variant */
+    badgeVariant?: "default" | "secondary" | "destructive" | "outline";
+    /** Tab icon */
+    icon?: ReactNode;
+    /** Tab content */
+    content: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+}
+/**
+ * Dialog configuration
+ */
+interface DialogConfig {
+    /** Dialog title */
+    title: string;
+    /** Dialog description */
+    description?: string;
+    /** Dialog size */
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+}
+/**
+ * Confirmation dialog configuration
+ */
+interface ConfirmDialogConfig extends DialogConfig {
+    /** Confirm button label */
+    confirmLabel?: string;
+    /** Cancel button label */
+    cancelLabel?: string;
+    /** Confirm button variant */
+    confirmVariant?: "default" | "destructive";
+    /** Whether action is in progress */
+    isLoading?: boolean;
+}
+/**
+ * Detail dialog field definition
+ */
+interface DetailField<T> {
+    /** Field key */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Value renderer */
+    render: (item: T) => ReactNode;
+    /** Full width */
+    fullWidth?: boolean;
+    /** Hide condition */
+    hidden?: (item: T) => boolean;
+}
+/**
+ * Form field types
+ */
+type FormFieldType = "text" | "number" | "boolean" | "select" | "textarea" | "code" | "password" | "email" | "date" | "datetime";
+/**
+ * Form field definition
+ */
+interface FormFieldDef {
+    /** Field key */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Field type */
+    type: FormFieldType;
+    /** Help text */
+    helpText?: string;
+    /** Required field */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Options for select fields */
+    options?: SelectOption[];
+    /** Validation function */
+    validate?: (value: unknown) => string | null;
+    /** Code editor language */
+    codeLanguage?: string;
+    /** Disabled condition */
+    disabled?: boolean;
+    /** Full width */
+    fullWidth?: boolean;
+}
+/**
+ * Select option
+ */
+interface SelectOption {
+    label: string;
+    value: string | number | boolean;
+    description?: string;
+}
+/**
+ * Dynamic parameter definition (for policy templates etc.)
+ */
+interface ParameterDef {
+    name: string;
+    type: "string" | "number" | "boolean" | "select";
+    helpText: string;
+    required: boolean;
+    defaultValue?: unknown;
+    options?: string[];
+}
+/**
+ * Status types with associated colors
+ */
+type StatusType = "pending" | "approved" | "rejected" | "committed" | "cancelled" | "mixed" | "ready" | "error" | "warning" | "info" | "success";
+/**
+ * Status configuration
+ */
+interface StatusConfig {
+    label: string;
+    variant: StatusType;
+    icon?: ReactNode;
+}
+/**
+ * Badge configuration for custom badges
+ */
+interface BadgeConfig {
+    label: string;
+    colorClass?: string;
+    variant?: "default" | "secondary" | "destructive" | "outline";
+}
+/**
+ * Action result for async operations
+ */
+interface ActionResult {
+    success: boolean;
+    message?: string;
+    error?: Error;
+}
+/**
+ * Async action handler type
+ */
+type AsyncActionHandler<T = void, R = ActionResult> = (arg: T) => Promise<R>;
+/**
+ * Approval decision
+ */
+interface ApprovalDecision$1 {
+    userId: string;
+    userName?: string;
+    userEmail?: string;
+    approved: boolean;
+    timestamp: string | number;
+    signature?: string;
+}
+/**
+ * Approval status with threshold
+ */
+interface ApprovalStatus {
+    approvalCount: number;
+    rejectionCount: number;
+    threshold: number;
+    decisions?: ApprovalDecision$1[];
+}
+/**
+ * Raw approval request for signing
+ */
+interface RawApprovalRequest {
+    changesetId: string;
+    changeSetDraftRequests: string;
+    requiresApprovalPopup?: boolean;
+}
+/**
+ * Signed approval response
+ */
+interface SignedApprovalResponse {
+    id: string;
+    approved?: {
+        request: Uint8Array;
+    };
+    denied?: boolean;
+}
+interface AutoRefreshOptions {
+    /** Refresh interval in seconds */
+    intervalSeconds: number;
+    /** Whether auto-refresh is enabled */
+    enabled?: boolean;
+    /** Refresh callback */
+    refresh: () => void | Promise<unknown>;
+    /** Block refresh while condition is true */
+    isBlocked?: boolean;
+    /** Error callback - called when refresh fails */
+    onError?: (error: Error) => void;
+    /** Max consecutive failures before stopping (default: unlimited) */
+    maxRetries?: number;
+}
+interface AutoRefreshReturn {
+    /** Seconds until next refresh */
+    secondsRemaining: number | null;
+    /** Trigger immediate refresh */
+    refreshNow: () => Promise<void>;
+    /** Reset the timer */
+    resetTimer: () => void;
+    /** Last error from refresh (null if no error) */
+    lastError: Error | null;
+    /** Number of consecutive failures */
+    failureCount: number;
+    /** Whether auto-refresh stopped due to max retries */
+    isStopped: boolean;
+}
+/**
+ * Selection hook return type
+ */
+interface SelectionReturn<T extends BaseDataItem> {
+    /** Currently selected item IDs */
+    selectedIds: string[];
+    /** Check if item is selected */
+    isSelected: (id: string) => boolean;
+    /** Toggle item selection */
+    toggle: (id: string) => void;
+    /** Select all items */
+    selectAll: (items: T[]) => void;
+    /** Clear all selections */
+    clearAll: () => void;
+    /** Toggle all items */
+    toggleAll: (items: T[]) => void;
+    /** Get selected items from a list */
+    getSelected: (items: T[]) => T[];
+    /** Whether all items are selected */
+    allSelected: (items: T[]) => boolean;
+    /** Whether some (but not all) items are selected */
+    someSelected: (items: T[]) => boolean;
+}
+/**
+ * Pagination hook return type
+ */
+interface PaginationReturn {
+    page: number;
+    pageSize: number;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    canNextPage: boolean;
+    canPrevPage: boolean;
+    totalPages: number;
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Toast notification type
+ */
+interface ToastConfig {
+    title: string;
+    description?: string;
+    variant?: "default" | "destructive";
+    duration?: number;
+}
+/**
+ * Empty state configuration
+ */
+interface EmptyStateConfig {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+/**
+ * Loading state configuration
+ */
+interface LoadingStateConfig {
+    /** Number of skeleton rows */
+    rows?: number;
+    /** Type of skeleton */
+    type?: "table" | "card" | "list";
+}
+/**
+ * Framework configuration
+ */
+interface FrameworkConfig {
+    /** Toast function (from your toast library) */
+    toast?: (config: ToastConfig) => void;
+    /** Custom class name generator */
+    cn?: (...inputs: unknown[]) => string;
+    /** Default page size */
+    defaultPageSize?: number;
+    /** Default auto-refresh interval */
+    defaultRefreshInterval?: number;
+}
+
+/**
+ * Merge Tailwind classes with clsx
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Convert base64 string to Uint8Array
+ */
+declare function base64ToBytes(base64: string): Uint8Array;
+/**
+ * Convert Uint8Array to base64 string
+ */
+declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Format timestamp to locale string
+ */
+declare function formatTimestamp(timestamp: string | number, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Format date for logs (includes seconds)
+ */
+declare function formatLogTimestamp(timestampMs: number): string;
+/**
+ * Compute optimal number of rows for viewport height
+ */
+declare function computeRowsForViewportHeight(viewportHeight: number, headerPx?: number, rowPx?: number): number;
+/**
+ * Delay helper for async operations
+ */
+declare function delay(ms: number): Promise<void>;
+/**
+ * Safe JSON parse
+ */
+declare function safeJsonParse<T>(json: string, fallback: T): T;
+/**
+ * Truncate text with ellipsis
+ */
+declare function truncate(text: string, maxLength: number): string;
+/**
+ * Check if a value is defined (not null or undefined)
+ */
+declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Generate unique ID
+ */
+declare function generateId(): string;
+
+/**
+ * Hook for auto-refreshing data at a configurable interval
+ *
+ * @example
+ * ```tsx
+ * const { secondsRemaining, refreshNow, lastError, failureCount } = useAutoRefresh({
+ *   intervalSeconds: 15,
+ *   refresh: fetchData,
+ *   isBlocked: isLoading,
+ *   onError: (err) => console.error('Refresh failed:', err),
+ *   maxRetries: 3,
+ * });
+ * ```
+ */
+declare function useAutoRefresh(options: AutoRefreshOptions): AutoRefreshReturn;
+
+/**
+ * Hook for managing multi-select state in tables
+ *
+ * @example
+ * ```tsx
+ * const selection = useSelection<MyItem>();
+ *
+ * // Toggle single item
+ * selection.toggle(item.id);
+ *
+ * // Check if selected
+ * const isSelected = selection.isSelected(item.id);
+ *
+ * // Toggle all
+ * selection.toggleAll(items);
+ * ```
+ */
+declare function useSelection<T extends BaseDataItem>(): SelectionReturn<T>;
+
+type PageSizeMode = "auto" | "manual";
+interface UsePaginationOptions {
+    /** Initial page (0-indexed) */
+    initialPage?: number;
+    /** Initial page size */
+    initialPageSize?: number;
+    /** Total number of items (for calculating total pages) */
+    totalItems?: number;
+    /** Whether to enable auto page size based on viewport */
+    autoPageSize?: boolean;
+    /** Ref to viewport element for auto sizing */
+    viewportRef?: React.RefObject<HTMLDivElement>;
+    /** Callback when page changes */
+    onPageChange?: (page: number) => void;
+    /** Callback when page size changes */
+    onPageSizeChange?: (pageSize: number) => void;
+}
+/**
+ * Hook for managing pagination state
+ *
+ * @example
+ * ```tsx
+ * const pagination = usePagination({
+ *   initialPageSize: 25,
+ *   totalItems: data.length,
+ * });
+ *
+ * // Use in query
+ * const { data } = useQuery({
+ *   queryKey: ['items', pagination.page, pagination.pageSize],
+ *   queryFn: () => fetchItems(pagination.pageSize, pagination.page * pagination.pageSize),
+ * });
+ * ```
+ */
+declare function usePagination(options?: UsePaginationOptions): PaginationReturn & {
+    pageSizeMode: PageSizeMode;
+    setPageSizeMode: (mode: PageSizeMode) => void;
+    pageSizeSelectValue: string;
+    onPageSizeSelect: (value: string) => void;
+};
+
+interface RefreshButtonProps {
+    onClick: () => void;
+    isRefreshing: boolean;
+    secondsRemaining: number | null;
+    disabled?: boolean;
+    className?: string;
+    "data-testid"?: string;
+    title?: string;
+    /** Accessible label for screen readers */
+    "aria-label"?: string;
+    ButtonComponent?: React$1.ComponentType<{
+        variant?: string;
+        onClick: () => void;
+        disabled?: boolean;
+        "data-testid"?: string;
+        title?: string;
+        className?: string;
+        style?: React$1.CSSProperties;
+        "aria-label"?: string;
+        "aria-busy"?: boolean;
+        children: React$1.ReactNode;
+    }>;
+}
+/**
+ * RefreshButton - Displays refresh button with auto-refresh countdown
+ *
+ * @example
+ * ```tsx
+ * <RefreshButton
+ *   onClick={() => void refreshNow()}
+ *   isRefreshing={isLoading}
+ *   secondsRemaining={secondsRemaining}
+ *   title="Refresh now"
+ * />
+ * ```
+ */
+declare function RefreshButton({ onClick, isRefreshing, secondsRemaining, disabled, className, "data-testid": dataTestId, title, "aria-label": ariaLabel, ButtonComponent, }: RefreshButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const STATUS_COLORS: Record<StatusType, string>;
+/**
+ * Default status icons
+ */
+declare const STATUS_ICONS: Record<StatusType, React$1.ComponentType<{
+    style?: React$1.CSSProperties;
+}>>;
+interface StatusBadgeProps {
+    /** Status type */
+    status: StatusType | string;
+    /** Custom label (defaults to capitalized status) */
+    label?: string;
+    /** Show icon */
+    showIcon?: boolean;
+    /** Custom icon override */
+    icon?: React$1.ReactNode;
+    /** Additional class name */
+    className?: string;
+    /** Custom status configurations for non-standard statuses */
+    customStatuses?: Record<string, {
+        colorClass?: string;
+        style?: React$1.CSSProperties;
+        icon?: React$1.ComponentType<{
+            style?: React$1.CSSProperties;
+        }>;
+    }>;
+    /** Custom badge component */
+    BadgeComponent?: React$1.ComponentType<{
+        variant?: string;
+        className?: string;
+        style?: React$1.CSSProperties;
+        children: React$1.ReactNode;
+    }>;
+}
+/**
+ * StatusBadge - Displays a colored badge based on status
+ *
+ * @example
+ * ```tsx
+ * <StatusBadge status="pending" />
+ * <StatusBadge status="approved" showIcon />
+ * <StatusBadge status="custom" customStatuses={{ custom: { style: { backgroundColor: "#fdf4ff", color: "#a21caf" } } }} />
+ * ```
+ */
+declare function StatusBadge({ status, label, showIcon, icon, className, customStatuses, BadgeComponent, }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+/**
+ * Helper to get status badge configuration
+ */
+declare function getStatusConfig(status: string): StatusConfig;
+
+/**
+ * Action button color presets (Tailwind classes for custom Button components)
+ */
+declare const ACTION_COLORS: {
+    readonly view: "text-cyan-600 dark:text-cyan-400";
+    readonly review: "text-cyan-600 dark:text-cyan-400";
+    readonly approve: "text-green-600 dark:text-green-400";
+    readonly commit: "text-green-600 dark:text-green-400";
+    readonly reject: "text-red-600 dark:text-red-400";
+    readonly delete: "text-red-600 dark:text-red-400";
+    readonly cancel: "text-red-600 dark:text-red-400";
+    readonly revoke: "text-orange-600 dark:text-orange-400";
+    readonly edit: "text-blue-600 dark:text-blue-400";
+    readonly create: "text-primary";
+    readonly download: "text-purple-600 dark:text-purple-400";
+    readonly settings: "text-gray-600 dark:text-gray-400";
+    readonly default: "";
+};
+type ActionType = keyof typeof ACTION_COLORS;
+/**
+ * Default icons for action types
+ */
+declare const ACTION_ICONS: Record<ActionType, React$1.ComponentType<{
+    className?: string;
+}>>;
+interface ActionButtonProps {
+    /** Action type for automatic styling */
+    action?: ActionType;
+    /** Click handler */
+    onClick: () => void | Promise<void>;
+    /** Custom icon override */
+    icon?: React$1.ReactNode;
+    /** Button label (for accessibility) */
+    label?: string;
+    /** Tooltip title */
+    title?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Custom color class override */
+    colorClass?: string;
+    /** Additional class name */
+    className?: string;
+    /** Button size */
+    size?: "sm" | "md" | "lg";
+    /** Button variant */
+    variant?: "ghost" | "outline" | "default";
+    /** Custom button component */
+    ButtonComponent?: React$1.ComponentType<{
+        size?: string;
+        variant?: string;
+        onClick: () => void;
+        disabled?: boolean;
+        title?: string;
+        className?: string;
+        children: React$1.ReactNode;
+    }>;
+}
+/**
+ * ActionButton - Icon button with preset action types
+ *
+ * @example
+ * ```tsx
+ * <ActionButton action="view" onClick={() => handleView(item)} title="View details" />
+ * <ActionButton action="delete" onClick={() => handleDelete(item)} title="Delete item" />
+ * ```
+ */
+declare function ActionButton({ action, onClick, icon, label, title, disabled, isLoading, colorClass, className, size, variant, ButtonComponent, }: ActionButtonProps): react_jsx_runtime.JSX.Element;
+interface ActionButtonGroupProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+/**
+ * ActionButtonGroup - Container for action buttons
+ */
+declare function ActionButtonGroup({ children, className }: ActionButtonGroupProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps extends EmptyStateConfig {
+    /** Additional class name */
+    className?: string;
+    /** Custom button component for action */
+    ButtonComponent?: React$1.ComponentType<{
+        onClick: () => void;
+        children: React$1.ReactNode;
+        className?: string;
+        style?: React$1.CSSProperties;
+    }>;
+}
+/**
+ * EmptyState - Displays when there's no data
+ *
+ * @example
+ * ```tsx
+ * <EmptyState
+ *   icon={<FileKey style={{ height: "3rem", width: "3rem" }} />}
+ *   title="No pending requests"
+ *   description="New requests will appear here."
+ * />
+ * ```
+ */
+declare function EmptyState({ icon, title, description, action, className, ButtonComponent, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+/**
+ * Preset empty states for common scenarios
+ */
+declare function EmptyStateNoData({ title, description, ...props }: Partial<EmptyStateProps>): react_jsx_runtime.JSX.Element;
+declare function EmptyStateNoResults({ title, description, ...props }: Partial<EmptyStateProps>): react_jsx_runtime.JSX.Element;
+declare function EmptyStateNoFiles({ title, description, ...props }: Partial<EmptyStateProps>): react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps {
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+/**
+ * Base Skeleton component with inline styles
+ */
+declare function Skeleton$1({ className, style }: SkeletonProps): react_jsx_runtime.JSX.Element;
+interface LoadingSkeletonProps {
+    /** Number of skeleton rows */
+    rows?: number;
+    /** Type of skeleton layout */
+    type?: "table" | "card" | "list";
+    /** Additional class name */
+    className?: string;
+    /** Custom skeleton component */
+    SkeletonComponent?: React$1.ComponentType<{
+        className?: string;
+        style?: React$1.CSSProperties;
+    }>;
+}
+/**
+ * LoadingSkeleton - Displays loading state with skeleton placeholders
+ *
+ * @example
+ * ```tsx
+ * <LoadingSkeleton rows={5} type="table" />
+ * ```
+ */
+declare function LoadingSkeleton({ rows, type, className, SkeletonComponent, }: LoadingSkeletonProps): react_jsx_runtime.JSX.Element;
+/**
+ * TableRowSkeleton - Single skeleton row for tables
+ */
+declare function TableRowSkeleton({ columns, className, SkeletonComponent, }: {
+    columns?: number;
+    className?: string;
+    SkeletonComponent?: React$1.ComponentType<{
+        className?: string;
+        style?: React$1.CSSProperties;
+    }>;
+}): react_jsx_runtime.JSX.Element;
+
+interface DataTableProps<T extends BaseDataItem> {
+    /** Data items to display */
+    data: T[];
+    /** Column definitions */
+    columns: ColumnDef<T>[];
+    /** Loading state */
+    isLoading?: boolean;
+    /** Row key getter (defaults to item.id) */
+    getRowKey?: (item: T) => string;
+    /** Row click handler */
+    onRowClick?: (item: T) => void;
+    /** Selected row IDs for highlighting */
+    selectedIds?: string[];
+    /** Empty state configuration */
+    emptyState?: EmptyStateConfig;
+    /** Additional class name */
+    className?: string;
+    /** Custom table components */
+    components?: {
+        Table?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+            style?: React$1.CSSProperties;
+        }>;
+        TableHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableBody?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableRow?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+            style?: React$1.CSSProperties;
+            onClick?: () => void;
+        }>;
+        TableHead?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+            style?: React$1.CSSProperties;
+        }>;
+        TableCell?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+            style?: React$1.CSSProperties;
+        }>;
+        Skeleton?: React$1.ComponentType<{
+            className?: string;
+            style?: React$1.CSSProperties;
+        }>;
+    };
+}
+/**
+ * DataTable - Generic data table component
+ *
+ * @example
+ * ```tsx
+ * <DataTable
+ *   data={items}
+ *   columns={[
+ *     { key: 'name', header: 'Name', cell: (item) => item.name },
+ *     { key: 'status', header: 'Status', cell: (item) => <StatusBadge status={item.status} /> },
+ *     { key: 'actions', header: 'Actions', cell: (item) => <ActionButton action="view" onClick={() => view(item)} /> },
+ *   ]}
+ *   isLoading={isLoading}
+ *   emptyState={{ title: 'No items', description: 'Create an item to get started.' }}
+ * />
+ * ```
+ */
+declare function DataTable<T extends BaseDataItem>({ data, columns, isLoading, getRowKey, onRowClick, selectedIds, emptyState, className, components, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface PaginatedTableProps<T extends BaseDataItem> extends Omit<DataTableProps<T>, 'data'> {
+    /** Data items (all or paginated from server) */
+    data: T[];
+    /** Total items count (for server-side pagination) */
+    totalItems?: number;
+    /** Whether pagination is server-side */
+    serverSide?: boolean;
+    /** Current page (controlled) */
+    page?: number;
+    /** Page size (controlled) */
+    pageSize?: number;
+    /** Page change callback */
+    onPageChange?: (page: number) => void;
+    /** Page size change callback */
+    onPageSizeChange?: (pageSize: number) => void;
+    /** Whether to show pagination controls */
+    showPagination?: boolean;
+    /** Available page sizes */
+    pageSizes?: number[];
+    /** Whether to enable auto page size */
+    autoPageSize?: boolean;
+    /** Header content (rendered above table) */
+    headerContent?: React$1.ReactNode;
+    /** Custom components */
+    components?: DataTableProps<T>['components'] & {
+        Select?: React$1.ComponentType<{
+            value: string;
+            onValueChange: (value: string) => void;
+            children: React$1.ReactNode;
+        }>;
+        SelectTrigger?: React$1.ComponentType<{
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+        SelectValue?: React$1.ComponentType<Record<string, unknown>>;
+        SelectContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        SelectItem?: React$1.ComponentType<{
+            value: string;
+            children: React$1.ReactNode;
+        }>;
+        Button?: React$1.ComponentType<{
+            size?: string;
+            variant?: string;
+            onClick?: () => void;
+            disabled?: boolean;
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+    };
+}
+/**
+ * PaginatedTable - DataTable with built-in pagination
+ *
+ * @example
+ * ```tsx
+ * // Client-side pagination
+ * <PaginatedTable
+ *   data={items}
+ *   columns={columns}
+ *   showPagination
+ * />
+ *
+ * // Server-side pagination
+ * <PaginatedTable
+ *   data={pageData}
+ *   columns={columns}
+ *   serverSide
+ *   totalItems={totalCount}
+ *   page={page}
+ *   pageSize={pageSize}
+ *   onPageChange={setPage}
+ *   onPageSizeChange={setPageSize}
+ * />
+ * ```
+ */
+declare function PaginatedTable<T extends BaseDataItem>({ data, totalItems, serverSide, page: controlledPage, pageSize: controlledPageSize, onPageChange, onPageSizeChange, showPagination, pageSizes, autoPageSize, headerContent, components, className, ...tableProps }: PaginatedTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface TabsViewProps {
+    /** Tab definitions */
+    tabs: TabDef[];
+    /** Currently active tab key */
+    activeTab: string;
+    /** Tab change callback */
+    onTabChange: (tabKey: string) => void;
+    /** Additional class name */
+    className?: string;
+    /** Tab list class name */
+    tabListClassName?: string;
+    /** Custom components */
+    components?: {
+        Tabs?: React$1.ComponentType<{
+            value: string;
+            onValueChange: (value: string) => void;
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        TabsList?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        TabsTrigger?: React$1.ComponentType<{
+            value: string;
+            disabled?: boolean;
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+        TabsContent?: React$1.ComponentType<{
+            value: string;
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+        Badge?: React$1.ComponentType<{
+            variant?: string;
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+    };
+}
+/**
+ * TabsView - Generic tabbed view component
+ *
+ * @example
+ * ```tsx
+ * <TabsView
+ *   tabs={[
+ *     { key: 'access', label: 'Access', badge: 5, content: <AccessTab /> },
+ *     { key: 'roles', label: 'Roles', badge: 2, content: <RolesTab /> },
+ *     { key: 'policies', label: 'Policies', content: <PoliciesTab /> },
+ *   ]}
+ *   activeTab={activeTab}
+ *   onTabChange={setActiveTab}
+ * />
+ * ```
+ */
+declare function TabsView({ tabs, activeTab, onTabChange, className, tabListClassName, components, }: TabsViewProps): react_jsx_runtime.JSX.Element;
+
+interface DetailDialogProps<T extends BaseDataItem> {
+    /** Whether dialog is open */
+    open: boolean;
+    /** Close handler */
+    onClose: () => void;
+    /** Item to display */
+    item: T | null;
+    /** Dialog title */
+    title: string;
+    /** Dialog description */
+    description?: string;
+    /** Field definitions */
+    fields: DetailField<T>[];
+    /** Footer content (actions) */
+    footer?: React$1.ReactNode;
+    /** Additional content after fields */
+    children?: React$1.ReactNode;
+    /** Dialog size */
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    /** Additional class name */
+    className?: string;
+    /** Custom components */
+    components?: {
+        Dialog?: React$1.ComponentType<{
+            open: boolean;
+            onOpenChange: (open: boolean) => void;
+            children: React$1.ReactNode;
+        }>;
+        DialogContent?: React$1.ComponentType<{
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+        DialogHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        DialogTitle?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        DialogDescription?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        DialogFooter?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+    };
+}
+/**
+ * DetailDialog - Dialog for displaying item details
+ *
+ * @example
+ * ```tsx
+ * <DetailDialog
+ *   open={!!selectedItem}
+ *   onClose={() => setSelectedItem(null)}
+ *   item={selectedItem}
+ *   title="Policy Details"
+ *   fields={[
+ *     { key: 'role', label: 'Role', render: (item) => item.roleId },
+ *     { key: 'status', label: 'Status', render: (item) => <StatusBadge status={item.status} /> },
+ *   ]}
+ *   footer={<Button onClick={() => handleApprove()}>Approve</Button>}
+ * />
+ * ```
+ */
+declare function DetailDialog<T extends BaseDataItem>({ open, onClose, item, title, description, fields, footer, children, size, className, components, }: DetailDialogProps<T>): react_jsx_runtime.JSX.Element | null;
+
+interface ConfirmDialogProps {
+    /** Whether dialog is open */
+    open: boolean;
+    /** Close handler */
+    onClose: () => void;
+    /** Confirm handler */
+    onConfirm: () => void | Promise<void>;
+    /** Dialog title */
+    title: string;
+    /** Dialog description */
+    description: string;
+    /** Confirm button label */
+    confirmLabel?: string;
+    /** Cancel button label */
+    cancelLabel?: string;
+    /** Confirm button variant */
+    confirmVariant?: "default" | "destructive";
+    /** Whether action is in progress */
+    isLoading?: boolean;
+    /** Additional class name */
+    className?: string;
+    /** Custom components */
+    components?: {
+        AlertDialog?: React$1.ComponentType<{
+            open: boolean;
+            onOpenChange: (open: boolean) => void;
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogTitle?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogDescription?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogFooter?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogAction?: React$1.ComponentType<{
+            onClick: () => void;
+            className?: string;
+            style?: React$1.CSSProperties;
+            disabled?: boolean;
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogCancel?: React$1.ComponentType<{
+            onClick?: () => void;
+            children: React$1.ReactNode;
+        }>;
+    };
+}
+/**
+ * ConfirmDialog - Confirmation dialog for destructive actions
+ *
+ * @example
+ * ```tsx
+ * <ConfirmDialog
+ *   open={showDelete}
+ *   onClose={() => setShowDelete(false)}
+ *   onConfirm={handleDelete}
+ *   title="Delete Item"
+ *   description="Are you sure? This action cannot be undone."
+ *   confirmLabel="Delete"
+ *   confirmVariant="destructive"
+ *   isLoading={isDeleting}
+ * />
+ * ```
+ */
+declare function ConfirmDialog({ open, onClose, onConfirm, title, description, confirmLabel, cancelLabel, confirmVariant, isLoading, className, components, }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleSectionProps {
+    /** Trigger/header content */
+    trigger: React$1.ReactNode;
+    /** Collapsible content */
+    children: React$1.ReactNode;
+    /** Default open state */
+    defaultOpen?: boolean;
+    /** Controlled open state */
+    open?: boolean;
+    /** Open state change handler */
+    onOpenChange?: (open: boolean) => void;
+    /** Icon to show when collapsed */
+    collapsedIcon?: React$1.ReactNode;
+    /** Icon to show when expanded */
+    expandedIcon?: React$1.ReactNode;
+    /** Additional class name */
+    className?: string;
+    /** Trigger class name */
+    triggerClassName?: string;
+    /** Content class name */
+    contentClassName?: string;
+    /** Custom components */
+    components?: {
+        Collapsible?: React$1.ComponentType<{
+            open: boolean;
+            onOpenChange: (open: boolean) => void;
+            children: React$1.ReactNode;
+        }>;
+        CollapsibleTrigger?: React$1.ComponentType<{
+            asChild?: boolean;
+            children: React$1.ReactNode;
+        }>;
+        CollapsibleContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Button?: React$1.ComponentType<{
+            variant?: string;
+            size?: string;
+            className?: string;
+            children: React$1.ReactNode;
+            onClick?: () => void;
+        }>;
+    };
+}
+/**
+ * CollapsibleSection - Expandable content section
+ *
+ * @example
+ * ```tsx
+ * <CollapsibleSection
+ *   trigger={<><Code className="h-4 w-4" /> View Code</>}
+ *   defaultOpen={false}
+ * >
+ *   <pre className="p-3 text-xs font-mono">{code}</pre>
+ * </CollapsibleSection>
+ * ```
+ */
+declare function CollapsibleSection({ trigger, children, defaultOpen, open: controlledOpen, onOpenChange, collapsedIcon, expandedIcon, className, triggerClassName, contentClassName, components, }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
+/**
+ * CodePreview - Pre-styled collapsible code section
+ */
+declare function CodePreview({ code, language, label, icon, maxHeight, className, ...props }: {
+    code: string;
+    language?: string;
+    label?: string;
+    icon?: React$1.ReactNode;
+    maxHeight?: string;
+    className?: string;
+} & Omit<CollapsibleSectionProps, 'trigger' | 'children'>): react_jsx_runtime.JSX.Element;
+
+interface BaseApprovalItem extends BaseDataItem {
+    status: string;
+    timestamp: string | number;
+    retrievalInfo?: ChangeSetRequest;
+}
+interface AccessApprovalItem extends BaseApprovalItem {
+    username: string;
+    role: string;
+    clientId: string;
+    commitReady: boolean;
+    decisionMade: boolean;
+    rejectionFound?: boolean;
+}
+interface RoleApprovalItem extends BaseApprovalItem {
+    role: string;
+    compositeRole?: string;
+    clientId: string;
+    requestType: string;
+    requestedBy: string;
+}
+interface PolicyApprovalItem extends BaseApprovalItem {
+    roleId: string;
+    requestedBy: string;
+    requestedByEmail?: string;
+    threshold: number;
+    approvalCount: number;
+    rejectionCount?: number;
+    commitReady?: boolean;
+    approvedBy?: string[];
+    deniedBy?: string[];
+    policyRequestData: string;
+    contractCode?: string;
+}
+interface ApprovalDecision {
+    decidedBy: string;
+    decidedByEmail?: string;
+    decision: "approved" | "rejected";
+    timestamp: string | number;
+}
+interface ApprovalTabConfig<T extends BaseApprovalItem> {
+    key: string;
+    label: string;
+    icon?: React$1.ReactNode;
+    /** Data fetcher */
+    fetchData: () => Promise<T[]>;
+    /** Column definitions for the table */
+    columns: ColumnDef<T>[];
+    /** Empty state configuration */
+    emptyState: {
+        icon: React$1.ReactNode;
+        title: string;
+        description: string;
+    };
+    /** Action handlers */
+    actions: {
+        onReview?: (item: T) => Promise<void>;
+        onCommit?: (item: T) => Promise<void>;
+        onCancel?: (item: T) => Promise<void>;
+        onRevoke?: (item: T) => Promise<void>;
+        onView?: (item: T) => void;
+        onDelete?: (item: T) => Promise<void>;
+    };
+    /** Check if item is ready to commit */
+    canCommit?: (item: T) => boolean;
+    /** Check if user has made a decision */
+    hasUserDecided?: (item: T) => boolean;
+    /** Query keys for cache invalidation */
+    queryKeys?: string[];
+}
+interface ApprovalsPageBaseProps<TAccess extends AccessApprovalItem = AccessApprovalItem, TRole extends RoleApprovalItem = RoleApprovalItem, TPolicy extends PolicyApprovalItem = PolicyApprovalItem> {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Tab configurations for default tabs */
+    tabs: {
+        access?: ApprovalTabConfig<TAccess>;
+        roles?: ApprovalTabConfig<TRole>;
+        policies?: ApprovalTabConfig<TPolicy>;
+    };
+    /** Additional custom tabs */
+    additionalTabs?: ApprovalTabConfig<any>[];
+    /** Initial active tab (can be any tab key) */
+    initialTab?: string;
+    /** Toast notification handler */
+    toast?: (config: ToastConfig) => void;
+    /** Auto-refresh interval in seconds */
+    refreshInterval?: number;
+    /** Query invalidation handler */
+    invalidateQueries?: (queryKeys: string[]) => void;
+    /** Current user ID (for checking decisions) */
+    currentUserId?: string;
+    /** Custom components */
+    components?: {
+        Card?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        CardContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Button?: React$1.ComponentType<any>;
+        Badge?: React$1.ComponentType<any>;
+        Skeleton?: React$1.ComponentType<{
+            className?: string;
+        }>;
+        Table?: React$1.ComponentType<any>;
+        TableHeader?: React$1.ComponentType<any>;
+        TableBody?: React$1.ComponentType<any>;
+        TableRow?: React$1.ComponentType<any>;
+        TableHead?: React$1.ComponentType<any>;
+        TableCell?: React$1.ComponentType<any>;
+        Tabs?: React$1.ComponentType<any>;
+        TabsList?: React$1.ComponentType<any>;
+        TabsTrigger?: React$1.ComponentType<any>;
+        TabsContent?: React$1.ComponentType<any>;
+        Dialog?: React$1.ComponentType<any>;
+        DialogContent?: React$1.ComponentType<any>;
+        DialogHeader?: React$1.ComponentType<any>;
+        DialogTitle?: React$1.ComponentType<any>;
+        DialogDescription?: React$1.ComponentType<any>;
+        DialogFooter?: React$1.ComponentType<any>;
+    };
+    /** Additional class name */
+    className?: string;
+    /** Optional help text shown below description */
+    helpText?: React$1.ReactNode;
+}
+/**
+ * ApprovalsPage - Generic approvals page with tabs for access, roles, and policies
+ *
+ * @example
+ * ```tsx
+ * <ApprovalsPage
+ *   tabs={{
+ *     access: {
+ *       key: 'access',
+ *       label: 'Access',
+ *       fetchData: api.admin.accessApprovals.list,
+ *       columns: accessColumns,
+ *       emptyState: { icon: <User />, title: 'No pending requests', description: '...' },
+ *       actions: {
+ *         onReview: handleReview,
+ *         onCommit: handleCommit,
+ *         onCancel: handleCancel,
+ *       },
+ *       canCommit: (item) => item.commitReady,
+ *     },
+ *     // ... other tabs
+ *   }}
+ *   toast={toast}
+ *   invalidateQueries={queryClient.invalidateQueries}
+ * />
+ * ```
+ */
+declare function ApprovalsPageBase<TAccess extends AccessApprovalItem = AccessApprovalItem, TRole extends RoleApprovalItem = RoleApprovalItem, TPolicy extends PolicyApprovalItem = PolicyApprovalItem>({ title, description, tabs, additionalTabs, initialTab, toast, refreshInterval, invalidateQueries, currentUserId, components, className, helpText, }: ApprovalsPageBaseProps<TAccess, TRole, TPolicy>): react_jsx_runtime.JSX.Element;
+/**
+ * Create user column for access approvals
+ */
+declare function createUserColumn<T extends {
+    username: string;
+}>(): ColumnDef<T>;
+/**
+ * Create role column
+ */
+declare function createRoleColumn<T extends {
+    role?: string;
+    roleId?: string;
+}>(): ColumnDef<T>;
+/**
+ * Create timestamp column
+ */
+declare function createTimestampColumn<T extends {
+    timestamp?: string | number;
+    createdAt?: number;
+}>(options?: {
+    header?: string;
+    responsive?: "sm" | "md" | "lg";
+}): ColumnDef<T>;
+/**
+ * Create status column
+ */
+declare function createStatusColumn<T extends {
+    status?: string;
+    commitReady?: boolean;
+}>(options?: {
+    getStatus?: (item: T) => string;
+}): ColumnDef<T>;
+/**
+ * Create progress column for threshold-based approvals
+ */
+declare function createProgressColumn<T extends {
+    approvalCount?: number;
+    rejectionCount?: number;
+    threshold: number;
+}>(): ColumnDef<T>;
+
+interface BaseLogItem extends BaseDataItem {
+    timestamp: number;
+    type?: string;
+    action?: string;
+}
+interface AccessLogItem extends BaseLogItem {
+    type: string;
+    clientId?: string;
+    userId?: string;
+    ipAddress?: string;
+    details?: Record<string, any>;
+}
+interface PolicyLogItem extends BaseLogItem {
+    policyId: string;
+    roleId: string;
+    action: string;
+    performedBy: string;
+    performedByEmail?: string;
+    details?: string;
+    policyStatus?: string;
+    policyThreshold?: number;
+    approvalCount?: number;
+    rejectionCount?: number;
+}
+interface LogsTabConfig<T extends BaseLogItem> {
+    key: string;
+    label: string;
+    icon?: React$1.ReactNode;
+    /** Data fetcher - receives limit and offset */
+    fetchData: (limit: number, offset: number) => Promise<T[]>;
+    /** Column definitions for the table */
+    columns: ColumnDef<T>[];
+    /** Empty state configuration */
+    emptyState: {
+        icon: React$1.ReactNode;
+        title: string;
+        description: string;
+    };
+    /** Optional row click handler */
+    onRowClick?: (item: T) => void;
+    /** Query keys for cache invalidation */
+    queryKeys?: string[];
+}
+interface LogsPageBaseProps<TAccess extends AccessLogItem = AccessLogItem, TPolicy extends PolicyLogItem = PolicyLogItem> {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Tab configurations */
+    tabs: {
+        access?: LogsTabConfig<TAccess>;
+        sessions?: {
+            key: string;
+            label: string;
+            icon?: React$1.ReactNode;
+            /** Embedded content component */
+            content: React$1.ReactNode;
+        };
+        policies?: LogsTabConfig<TPolicy>;
+    };
+    /** Initial active tab */
+    initialTab?: "access" | "sessions" | "policies";
+    /** Toast notification handler */
+    toast?: (config: ToastConfig) => void;
+    /** Auto-refresh interval in seconds */
+    refreshInterval?: number;
+    /** Query invalidation handler */
+    invalidateQueries?: (queryKeys: string[]) => void;
+    /** Available page sizes */
+    pageSizes?: number[];
+    /** Enable auto page sizing */
+    autoPageSize?: boolean;
+    /** URL state management */
+    urlState?: {
+        tab: string;
+        setTab: (tab: string) => void;
+    };
+    /** Custom components */
+    components?: {
+        Card?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        CardContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Button?: React$1.ComponentType<any>;
+        Badge?: React$1.ComponentType<any>;
+        Skeleton?: React$1.ComponentType<{
+            className?: string;
+        }>;
+        Select?: React$1.ComponentType<any>;
+        SelectTrigger?: React$1.ComponentType<any>;
+        SelectValue?: React$1.ComponentType<any>;
+        SelectContent?: React$1.ComponentType<any>;
+        SelectItem?: React$1.ComponentType<any>;
+        Table?: React$1.ComponentType<any>;
+        TableHeader?: React$1.ComponentType<any>;
+        TableBody?: React$1.ComponentType<any>;
+        TableRow?: React$1.ComponentType<any>;
+        TableHead?: React$1.ComponentType<any>;
+        TableCell?: React$1.ComponentType<any>;
+        Tabs?: React$1.ComponentType<any>;
+        TabsList?: React$1.ComponentType<any>;
+        TabsTrigger?: React$1.ComponentType<any>;
+        TabsContent?: React$1.ComponentType<any>;
+        Dialog?: React$1.ComponentType<any>;
+        DialogContent?: React$1.ComponentType<any>;
+        DialogHeader?: React$1.ComponentType<any>;
+        DialogTitle?: React$1.ComponentType<any>;
+        DialogDescription?: React$1.ComponentType<any>;
+        DialogFooter?: React$1.ComponentType<any>;
+    };
+    /** Additional class name */
+    className?: string;
+    /** Optional help text shown below description */
+    helpText?: React$1.ReactNode;
+}
+/**
+ * LogsPage - Generic logs page with tabs for access, sessions, and policies
+ *
+ * @example
+ * ```tsx
+ * <LogsPage
+ *   tabs={{
+ *     access: {
+ *       key: 'access',
+ *       label: 'Access',
+ *       fetchData: (limit, offset) => api.admin.logs.access(limit, offset),
+ *       columns: accessColumns,
+ *       emptyState: { icon: <ScrollText />, title: 'No logs', description: '...' },
+ *     },
+ *     sessions: {
+ *       key: 'sessions',
+ *       label: 'Sessions',
+ *       content: <SessionHistoryContent />,
+ *     },
+ *     policies: {
+ *       key: 'policies',
+ *       label: 'Policies',
+ *       fetchData: (limit, offset) => api.admin.sshPolicies.getLogs(limit, offset),
+ *       columns: policyColumns,
+ *       emptyState: { icon: <Shield />, title: 'No policy logs', description: '...' },
+ *     },
+ *   }}
+ * />
+ * ```
+ */
+declare function LogsPageBase<TAccess extends AccessLogItem = AccessLogItem, TPolicy extends PolicyLogItem = PolicyLogItem>({ title, description, tabs, initialTab, toast, refreshInterval, invalidateQueries, pageSizes, autoPageSize, urlState, components, className, helpText, }: LogsPageBaseProps<TAccess, TPolicy>): react_jsx_runtime.JSX.Element;
+/**
+ * Create timestamp column for logs
+ */
+declare function createLogTimestampColumn<T extends {
+    timestamp?: number;
+    createdAt?: number;
+    time?: number;
+}>(options?: {
+    header?: string;
+    field?: "timestamp" | "createdAt" | "time";
+}): ColumnDef<T>;
+/**
+ * Create action column with icon and color
+ */
+declare function createActionColumn<T extends {
+    action: string;
+}>(): ColumnDef<T>;
+/**
+ * Create progress column for policy logs
+ */
+declare function createLogProgressColumn<T extends {
+    policyThreshold?: number;
+    approvalCount?: number;
+    rejectionCount?: number;
+}>(): ColumnDef<T>;
+
+interface TemplateParameter$1 {
+    name: string;
+    type: "string" | "number" | "boolean" | "select";
+    helpText: string;
+    required: boolean;
+    defaultValue?: any;
+    options?: string[];
+}
+interface PolicyTemplateItem$1 extends BaseDataItem {
+    name: string;
+    description: string;
+    csCode: string;
+    parameters: TemplateParameter$1[];
+    createdBy: string;
+}
+interface TemplateFormData {
+    name: string;
+    description: string;
+    csCode: string;
+    parameters: TemplateParameter$1[];
+}
+interface TemplatesPageBaseProps<T extends PolicyTemplateItem$1 = PolicyTemplateItem$1> {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Help text shown below description */
+    helpText?: React$1.ReactNode;
+    /** Data fetcher */
+    fetchData: () => Promise<{
+        templates: T[];
+    }>;
+    /** Create handler */
+    onCreate: (data: TemplateFormData) => Promise<void>;
+    /** Update handler */
+    onUpdate: (id: string, data: Partial<TemplateFormData>) => Promise<void>;
+    /** Delete handler */
+    onDelete: (id: string) => Promise<void>;
+    /** Check if user can edit templates */
+    canEdit?: boolean;
+    /** Default code for new templates */
+    defaultCode?: string;
+    /** Code editor language */
+    codeLanguage?: string;
+    /** Toast notification handler */
+    toast?: (config: ToastConfig) => void;
+    /** Auto-refresh interval in seconds */
+    refreshInterval?: number;
+    /** Query invalidation handler */
+    invalidateQueries?: (queryKeys: string[]) => void;
+    /** Query keys */
+    queryKeys?: string[];
+    /** Custom column definitions */
+    columns?: ColumnDef<T>[];
+    /** Empty state configuration */
+    emptyState?: {
+        icon?: React$1.ReactNode;
+        title?: string;
+        description?: string;
+    };
+    /** Custom components */
+    components?: {
+        Card?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        CardContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Button?: React$1.ComponentType<any>;
+        Badge?: React$1.ComponentType<any>;
+        Skeleton?: React$1.ComponentType<{
+            className?: string;
+        }>;
+        Input?: React$1.ComponentType<any>;
+        Textarea?: React$1.ComponentType<any>;
+        Label?: React$1.ComponentType<any>;
+        Switch?: React$1.ComponentType<any>;
+        Select?: React$1.ComponentType<any>;
+        SelectTrigger?: React$1.ComponentType<any>;
+        SelectValue?: React$1.ComponentType<any>;
+        SelectContent?: React$1.ComponentType<any>;
+        SelectItem?: React$1.ComponentType<any>;
+        Table?: React$1.ComponentType<any>;
+        TableHeader?: React$1.ComponentType<any>;
+        TableBody?: React$1.ComponentType<any>;
+        TableRow?: React$1.ComponentType<any>;
+        TableHead?: React$1.ComponentType<any>;
+        TableCell?: React$1.ComponentType<any>;
+        Dialog?: React$1.ComponentType<any>;
+        DialogContent?: React$1.ComponentType<any>;
+        DialogHeader?: React$1.ComponentType<any>;
+        DialogTitle?: React$1.ComponentType<any>;
+        DialogDescription?: React$1.ComponentType<any>;
+        DialogFooter?: React$1.ComponentType<any>;
+        AlertDialog?: React$1.ComponentType<any>;
+        AlertDialogContent?: React$1.ComponentType<any>;
+        AlertDialogHeader?: React$1.ComponentType<any>;
+        AlertDialogTitle?: React$1.ComponentType<any>;
+        AlertDialogDescription?: React$1.ComponentType<any>;
+        AlertDialogFooter?: React$1.ComponentType<any>;
+        AlertDialogAction?: React$1.ComponentType<any>;
+        AlertDialogCancel?: React$1.ComponentType<any>;
+        CodeEditor?: React$1.ComponentType<{
+            value: string;
+            onChange: (value: string) => void;
+            language?: string;
+            height?: string;
+        }>;
+    };
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * TemplatesPage - Generic template management page
+ *
+ * @example
+ * ```tsx
+ * <TemplatesPage
+ *   fetchData={api.admin.policyTemplates.list}
+ *   onCreate={api.admin.policyTemplates.create}
+ *   onUpdate={api.admin.policyTemplates.update}
+ *   onDelete={api.admin.policyTemplates.delete}
+ *   canEdit={canManageTemplates()}
+ *   toast={toast}
+ * />
+ * ```
+ */
+declare function TemplatesPageBase<T extends PolicyTemplateItem$1 = PolicyTemplateItem$1>({ title, description, helpText, fetchData, onCreate, onUpdate, onDelete, canEdit, defaultCode, codeLanguage, toast, refreshInterval, invalidateQueries, queryKeys, columns: customColumns, emptyState, components, className, }: TemplatesPageBaseProps<T>): react_jsx_runtime.JSX.Element;
+
+interface UserItem extends BaseDataItem {
+    username?: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    role: string | string[];
+    enabled: boolean;
+    linked?: boolean;
+    isAdmin?: boolean;
+}
+interface RoleItem$1 {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface UserFormData {
+    id: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    assignedRoles: string[];
+}
+interface CreateUserFormData {
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+}
+interface UsersPageBaseProps<T extends UserItem = UserItem> {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Whether the API is ready to be called (defaults to true for backwards compatibility) */
+    isReady?: boolean;
+    /** Data fetcher */
+    fetchUsers: () => Promise<T[]>;
+    /** Fetch available roles */
+    fetchRoles: () => Promise<{
+        roles: RoleItem$1[];
+    }>;
+    /** Create user handler */
+    onCreate: (data: CreateUserFormData) => Promise<void>;
+    /** Update profile handler */
+    onUpdateProfile: (data: {
+        id: string;
+        firstName: string;
+        lastName: string;
+        email: string;
+    }) => Promise<void>;
+    /** Update roles handler */
+    onUpdateRoles: (data: {
+        id: string;
+        rolesToAdd?: string[];
+        rolesToRemove?: string[];
+    }) => Promise<void>;
+    /** Delete user handler */
+    onDelete: (userId: string) => Promise<void>;
+    /** Set user enabled/disabled */
+    onSetEnabled?: (userId: string, enabled: boolean) => Promise<void>;
+    /** Get Tide link URL */
+    getTideLinkUrl?: (userId: string) => Promise<{
+        linkUrl: string;
+    }>;
+    /** Check if user can create more users */
+    checkUserLimit?: () => Promise<{
+        allowed: boolean;
+        current: number;
+        limit: number;
+        tierName?: string;
+    }>;
+    /** License info for over-limit warnings */
+    licenseInfo?: {
+        overLimit?: {
+            users: {
+                isOverLimit: boolean;
+                enabled: number;
+                limit: number;
+                overBy: number;
+            };
+        };
+    };
+    /** Toast handler */
+    toast?: (config: ToastConfig) => void;
+    /** Auto-refresh interval */
+    refreshInterval?: number;
+    /** Query invalidation */
+    invalidateQueries?: (queryKeys: string[]) => void;
+    /** Query keys */
+    queryKeys?: string[];
+    /** Custom columns */
+    columns?: ColumnDef<T>[];
+    /** Custom components */
+    components?: {
+        Card?: React$1.ComponentType<any>;
+        CardContent?: React$1.ComponentType<any>;
+        Button?: React$1.ComponentType<any>;
+        Badge?: React$1.ComponentType<any>;
+        Skeleton?: React$1.ComponentType<any>;
+        Input?: React$1.ComponentType<any>;
+        Label?: React$1.ComponentType<any>;
+        Switch?: React$1.ComponentType<any>;
+        ScrollArea?: React$1.ComponentType<any>;
+        Table?: React$1.ComponentType<any>;
+        TableHeader?: React$1.ComponentType<any>;
+        TableBody?: React$1.ComponentType<any>;
+        TableRow?: React$1.ComponentType<any>;
+        TableHead?: React$1.ComponentType<any>;
+        TableCell?: React$1.ComponentType<any>;
+        Dialog?: React$1.ComponentType<any>;
+        DialogContent?: React$1.ComponentType<any>;
+        DialogHeader?: React$1.ComponentType<any>;
+        DialogTitle?: React$1.ComponentType<any>;
+        DialogDescription?: React$1.ComponentType<any>;
+        DialogFooter?: React$1.ComponentType<any>;
+        AlertDialog?: React$1.ComponentType<any>;
+        AlertDialogContent?: React$1.ComponentType<any>;
+        AlertDialogHeader?: React$1.ComponentType<any>;
+        AlertDialogTitle?: React$1.ComponentType<any>;
+        AlertDialogDescription?: React$1.ComponentType<any>;
+        AlertDialogFooter?: React$1.ComponentType<any>;
+        AlertDialogAction?: React$1.ComponentType<any>;
+        AlertDialogCancel?: React$1.ComponentType<any>;
+        Alert?: React$1.ComponentType<any>;
+        AlertDescription?: React$1.ComponentType<any>;
+        UpgradeBanner?: React$1.ComponentType<any>;
+    };
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * UsersPage - Generic user management page
+ *
+ * @example
+ * ```tsx
+ * <UsersPage
+ *   fetchUsers={api.admin.users.list}
+ *   fetchRoles={() => api.admin.roles.listAll()}
+ *   onCreate={api.admin.users.add}
+ *   onUpdateProfile={api.admin.users.updateProfile}
+ *   onUpdateRoles={api.admin.users.updateRoles}
+ *   onDelete={api.admin.users.delete}
+ *   onSetEnabled={(id, enabled) => api.admin.users.setEnabled(id, enabled)}
+ *   toast={toast}
+ * />
+ * ```
+ */
+declare function UsersPageBase<T extends UserItem = UserItem>({ title, description, isReady, fetchUsers, fetchRoles, onCreate, onUpdateProfile, onUpdateRoles, onDelete, onSetEnabled, getTideLinkUrl, checkUserLimit, licenseInfo, toast, refreshInterval, invalidateQueries, queryKeys, columns: customColumns, components, className, }: UsersPageBaseProps<T>): react_jsx_runtime.JSX.Element;
+
+interface RoleItem extends BaseDataItem {
+    name: string;
+    description?: string;
+    clientRole?: boolean;
+    /** For display purposes - which type this role belongs to */
+    roleType?: "realm" | "client";
+}
+/** Role type configuration for RolesPage */
+type RoleTypeConfig = "realm" | "client" | "all";
+interface PolicyTemplateItem {
+    id: string;
+    name: string;
+    description?: string;
+    csCode: string;
+    parameters: TemplateParameter[];
+}
+interface TemplateParameter {
+    name: string;
+    type: "string" | "number" | "boolean" | "select";
+    required?: boolean;
+    defaultValue?: string | number | boolean;
+    helpText?: string;
+    options?: string[];
+}
+interface PolicyConfig {
+    enabled: boolean;
+    contractType: string;
+    approvalType: "implicit" | "explicit";
+    executionType: "public" | "private";
+    threshold: number;
+}
+interface RolesPageBaseProps<TRole extends RoleItem = RoleItem> {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Help text shown below description */
+    helpText?: React$1.ReactNode;
+    /** SSH role info text */
+    sshRoleInfo?: string;
+    /** Whether the API is ready to be called (defaults to true for backwards compatibility) */
+    isReady?: boolean;
+    /** Role type configuration: 'realm', 'client', or 'all' (default: 'realm') */
+    roleType?: RoleTypeConfig;
+    /** Special role prefix (e.g., "ssh:", "admin:"). Used to identify and auto-prefix special roles. */
+    specialRolePrefix?: string;
+    /** Special role type label (e.g., "SSH", "Admin"). Used for display purposes. */
+    specialRoleType?: string;
+    /** Fetch roles */
+    fetchRoles: () => Promise<{
+        roles: TRole[];
+    } | TRole[]>;
+    /** Fetch policy templates */
+    fetchTemplates?: () => Promise<{
+        templates: PolicyTemplateItem[];
+    } | PolicyTemplateItem[]>;
+    /** Fetch users for threshold calculation */
+    fetchUsers?: () => Promise<any[]>;
+    /** Fetch pending approvals */
+    fetchPendingApprovals?: () => Promise<any[]>;
+    /** Fetch existing policy for a role */
+    fetchRolePolicy?: (roleName: string) => Promise<{
+        policy: PolicyConfig | null;
+    }>;
+    /** Create role */
+    onCreate: (data: {
+        name: string;
+        description?: string;
+        policy?: PolicyConfig;
+        roleType?: "realm" | "client";
+    }) => Promise<void>;
+    /** Update role */
+    onUpdate: (data: {
+        name: string;
+        description?: string;
+    }) => Promise<void>;
+    /** Delete role */
+    onDelete: (roleName: string) => Promise<{
+        approvalCreated?: boolean;
+    }>;
+    /** Create policy request (for SSH roles) */
+    onCreatePolicy?: (params: {
+        roleName: string;
+        policyConfig: PolicyConfig;
+        templateId?: string;
+        templateParams?: Record<string, any>;
+        threshold: number;
+    }) => Promise<void>;
+    /** Contract type options */
+    contractTypes?: {
+        value: string;
+        label: string;
+        description?: string;
+    }[];
+    /** Default policy config */
+    defaultPolicyConfig?: PolicyConfig;
+    /** Check if role is a special prefixed role */
+    isSpecialRole?: (role: TRole | string) => boolean;
+    /** Normalize special role name (add prefix) */
+    normalizeSpecialRoleName?: (name: string) => string;
+    /** Customizable UI labels */
+    labels?: {
+        /** Special role prefix (default: "ssh:") */
+        specialRolePrefix?: string;
+        /** Special role type label (default: "SSH") */
+        specialRoleType?: string;
+        /** Special role checkbox label */
+        specialRoleCheckbox?: string;
+        /** Special role hint text */
+        specialRoleHint?: string;
+        /** Policy section title */
+        policySectionTitle?: string;
+        /** Policy section description */
+        policySectionDescription?: string;
+        /** Default policy option label */
+        defaultPolicyLabel?: string;
+        /** Default policy description */
+        defaultPolicyDescription?: string;
+        /** Create policy checkbox label */
+        createPolicyCheckbox?: string;
+        /** Role type labels */
+        clientRoleLabel?: string;
+        realmRoleLabel?: string;
+        /** Info text shown in header */
+        specialRoleInfo?: string;
+        /** Button labels */
+        addRoleButton?: string;
+        createButton?: string;
+        saveButton?: string;
+        cancelButton?: string;
+        deleteButton?: string;
+        /** Dialog titles */
+        addRoleTitle?: string;
+        editRoleTitle?: string;
+        deleteRoleTitle?: string;
+        /** Placeholders */
+        searchPlaceholder?: string;
+        roleNamePlaceholder?: string;
+        specialRoleNamePlaceholder?: string;
+        descriptionPlaceholder?: string;
+        /** Empty state */
+        noRolesTitle?: string;
+        noRolesDescription?: string;
+        /** No search results message */
+        noSearchResultsMessage?: string;
+        /** Messages */
+        roleCreatedMessage?: string;
+        roleUpdatedMessage?: string;
+        roleDeletedMessage?: string;
+        policyCreatedMessage?: string;
+        /** Badge text for special roles in table */
+        specialRoleBadge?: string;
+        /** Description for create role dialog */
+        createRoleDescription?: string;
+        /** Description for edit role dialog */
+        editRoleDescription?: string;
+        /** Role name disabled hint */
+        roleNameDisabledHint?: string;
+        /** Policy update warning */
+        policyUpdateWarning?: string;
+        /** Delete confirmation message */
+        deleteConfirmMessage?: string;
+        /** Approval request message */
+        approvalRequestMessage?: string;
+        /** No description text */
+        noDescriptionText?: string;
+        /** Loading policy text */
+        loadingPolicyText?: string;
+        /** Update signing policy checkbox label */
+        updatePolicyCheckbox?: string;
+        /** Policy template label */
+        policyTemplateLabel?: string;
+    };
+    /** Calculate threshold from users */
+    calculateThreshold?: (users: any[], pendingApprovals: any[]) => number;
+    /** Admin role set for threshold calculation */
+    adminRoleSet?: Set<string>;
+    /** Custom columns for role table */
+    columns?: ColumnDef<TRole>[];
+    /** Toast function */
+    toast?: (options: {
+        title: string;
+        description?: string;
+        variant?: string;
+    }) => void;
+    /** Invalidate queries */
+    invalidateQueries?: (keys: string[]) => void;
+    /** Query keys to invalidate on changes */
+    queryKeys?: string[];
+    /** Auto-refresh interval in seconds */
+    refreshInterval?: number;
+    /** Additional class name */
+    className?: string;
+    components?: {
+        Card?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        CardContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Button?: React$1.ComponentType<any>;
+        Badge?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            variant?: string;
+            className?: string;
+        }>;
+        Skeleton?: React$1.ComponentType<{
+            className?: string;
+        }>;
+        Input?: React$1.ComponentType<any>;
+        Label?: React$1.ComponentType<any>;
+        Textarea?: React$1.ComponentType<any>;
+        Checkbox?: React$1.ComponentType<any>;
+        Select?: React$1.ComponentType<any>;
+        SelectTrigger?: React$1.ComponentType<any>;
+        SelectValue?: React$1.ComponentType<any>;
+        SelectContent?: React$1.ComponentType<any>;
+        SelectItem?: React$1.ComponentType<any>;
+        Table?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableBody?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableRow?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        TableHead?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        TableCell?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        Dialog?: React$1.ComponentType<{
+            open: boolean;
+            onOpenChange: (open: boolean) => void;
+            children: React$1.ReactNode;
+        }>;
+        DialogContent?: React$1.ComponentType<{
+            className?: string;
+            children: React$1.ReactNode;
+        }>;
+        DialogHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        DialogTitle?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        DialogDescription?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        DialogFooter?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+            className?: string;
+        }>;
+        AlertDialog?: React$1.ComponentType<{
+            open: boolean;
+            onOpenChange: (open: boolean) => void;
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogContent?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogHeader?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogTitle?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogDescription?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogFooter?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogCancel?: React$1.ComponentType<{
+            children: React$1.ReactNode;
+        }>;
+        AlertDialogAction?: React$1.ComponentType<any>;
+        Separator?: React$1.ComponentType<{
+            className?: string;
+        }>;
+    };
+}
+declare function RolesPageBase<TRole extends RoleItem = RoleItem>({ title, description, helpText, isReady, roleType, specialRolePrefix, specialRoleType, fetchRoles, fetchTemplates, fetchUsers, fetchPendingApprovals, fetchRolePolicy, onCreate, onUpdate, onDelete, onCreatePolicy, contractTypes, defaultPolicyConfig, isSpecialRole: isSpecialRoleProp, normalizeSpecialRoleName: normalizeSpecialRoleNameProp, labels: customLabels, calculateThreshold, adminRoleSet, columns, toast, invalidateQueries, queryKeys, refreshInterval, className, components, }: RolesPageBaseProps<TRole>): react_jsx_runtime.JSX.Element;
+
+/** Implement this to store templates (or use createLocalStorageTemplateAPI for dev) */
+interface TemplateAPI {
+    getTemplates: () => Promise<PolicyTemplateItem$1[]>;
+    getTemplate?: (id: string) => Promise<PolicyTemplateItem$1>;
+    createTemplate: (data: TemplateFormData) => Promise<PolicyTemplateItem$1 | void>;
+    updateTemplate: (id: string, data: Partial<TemplateFormData>) => Promise<PolicyTemplateItem$1 | void>;
+    deleteTemplate: (id: string) => Promise<void>;
+    _isLocalStorage?: boolean;
+}
+/** localStorage adapter for development */
+declare function createLocalStorageTemplateAPI(storageKey?: string): TemplateAPI;
+interface TemplatesPageProps<T extends PolicyTemplateItem$1 = PolicyTemplateItem$1> extends Omit<TemplatesPageBaseProps<T>, "fetchData" | "onCreate" | "onUpdate" | "onDelete"> {
+    /** Template storage adapter */
+    api: TemplateAPI;
+    /** Override fetch templates */
+    fetchData?: TemplatesPageBaseProps<T>["fetchData"];
+    /** Override create */
+    onCreate?: TemplatesPageBaseProps<T>["onCreate"];
+    /** Override update */
+    onUpdate?: TemplatesPageBaseProps<T>["onUpdate"];
+    /** Override delete */
+    onDelete?: TemplatesPageBaseProps<T>["onDelete"];
+}
+declare function TemplatesPage<T extends PolicyTemplateItem$1 = PolicyTemplateItem$1>({ api, fetchData: fetchDataProp, onCreate: onCreateProp, onUpdate: onUpdateProp, onDelete: onDeleteProp, helpText: helpTextProp, ...props }: TemplatesPageProps<T>): react_jsx_runtime.JSX.Element;
+
+type AdminAPIInstance$3 = {
+    setRealm?: (realm: string) => void;
+    getAccessLogs: (params: {
+        first: number;
+        max: number;
+    }) => Promise<any>;
+};
+interface PolicyLogData {
+    id: string;
+    policyId: string;
+    roleId: string;
+    action: string;
+    performedBy: string;
+    performedByEmail?: string;
+    timestamp: number;
+    createdAt?: number;
+    policyStatus?: string;
+    policyThreshold?: number;
+    approvalCount?: number;
+    rejectionCount?: number;
+    details?: string;
+}
+/** Implement this to store policy logs (or use createLocalStoragePolicyLogsAPI for dev) */
+interface PolicyLogsAPI {
+    getPolicyLogs: (params: {
+        first: number;
+        max: number;
+    }) => Promise<PolicyLogData[]>;
+    addLog: (log: Omit<PolicyLogData, "id" | "timestamp" | "createdAt">) => Promise<void>;
+    _isLocalStorage?: boolean;
+}
+/** localStorage adapter for development */
+declare function createLocalStoragePolicyLogsAPI(storageKey?: string): PolicyLogsAPI;
+interface LogsPageProps extends Omit<LogsPageBaseProps, "tabs"> {
+    /** AdminAPI instance */
+    adminAPI?: AdminAPIInstance$3;
+    /** Policy logs adapter */
+    policyLogsAPI?: PolicyLogsAPI;
+    /** Realm name */
+    realm?: string;
+    /** Custom tabs config */
+    tabs?: LogsPageBaseProps["tabs"];
+    /** Show policy tab (default: true) */
+    showPolicyTab?: boolean;
+    /** Help text below description */
+    helpText?: LogsPageBaseProps["helpText"];
+}
+declare function LogsPage({ adminAPI: adminAPIProp, policyLogsAPI: policyLogsAPIProp, realm, tabs: tabsProp, showPolicyTab, helpText: helpTextProp, ...props }: LogsPageProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Tide Policy Workflow Helpers
+ *
+ * Provides functions for creating Tide policy requests that can be signed
+ * by the TideCloak context. Uses heimdall-tide and asgard-tide libraries.
+ *
+ * This is the default policy creation workflow used by RolesPage when
+ * Tide libraries are available.
+ */
+
+/**
+ * Attempts to load the Tide libraries (heimdall-tide and asgard-tide).
+ * Returns true if both libraries are available, false otherwise.
+ */
+declare function loadTideLibs(): Promise<boolean>;
+/**
+ * Checks if Tide libraries are available without loading them.
+ * Must call loadTideLibs() first.
+ */
+declare function areTideLibsAvailable(): boolean;
+declare const DEFAULT_MODEL_IDS: {
+    readonly BASIC: "BasicCustom<Role>:BasicCustom<1>";
+    readonly DYNAMIC: "DynamicCustom<Role>:DynamicCustom<1>";
+    readonly DYNAMIC_APPROVED: "DynamicApprovedCustom<Role>:DynamicApprovedCustom<1>";
+};
+/**
+ * Default Forseti contract for role-based access control.
+ * This is a simple contract that validates approvers and executors have the required role.
+ */
+declare const DEFAULT_ROLE_CONTRACT = "using Ork.Forseti.Sdk;\nusing System;\nusing System.Collections.Generic;\n\n/// <summary>\n/// Default Role-Based Access Policy.\n/// Validates that approvers and executors have the required role for a resource.\n/// </summary>\npublic class RolePolicy : IAccessPolicy\n{\n    [PolicyParam(Required = true, Description = \"Role required for access\")]\n    public string Role { get; set; }\n\n    [PolicyParam(Required = true, Description = \"Resource identifier for role check\")]\n    public string Resource { get; set; }\n\n    public PolicyDecision ValidateData(DataContext ctx)\n    {\n        // No data validation needed for role-based policies\n        return PolicyDecision.Allow();\n    }\n\n    public PolicyDecision ValidateApprovers(ApproversContext ctx)\n    {\n        var approvers = DokenDto.WrapAll(ctx.Dokens);\n        return Decision\n            .Require(approvers != null && approvers.Count > 0, \"No approver dokens provided\")\n            .RequireAnyWithRole(approvers, Resource, Role);\n    }\n\n    public PolicyDecision ValidateExecutor(ExecutorContext ctx)\n    {\n        var executor = new DokenDto(ctx.Doken);\n        return Decision\n            .RequireNotExpired(executor)\n            .RequireRole(executor, Resource, Role);\n    }\n}";
+interface TidePolicyConfig {
+    roleName: string;
+    threshold: number;
+    approvalType: "implicit" | "explicit";
+    executionType: "public" | "private";
+    modelId?: string;
+    resource: string;
+    vendorId: string;
+    contractCode?: string;
+}
+interface TideContextMethods {
+    initializeTideRequest: <T extends {
+        encode: () => Uint8Array;
+    }>(request: T) => Promise<T>;
+    getVendorId: () => string;
+    getResource: () => string;
+}
+/**
+ * Computes the contract ID (SHA512 hash) for a Forseti contract source.
+ * This must match what the Ork server computes.
+ */
+declare function computeContractId(source: string): Promise<string>;
+/**
+ * Creates a Tide PolicySignRequest for a role policy.
+ *
+ * @param config - Policy configuration
+ * @param context - TideCloak context methods for signing
+ * @returns The signed PolicySignRequest
+ * @throws Error if Tide libraries are not available
+ */
+declare function createTidePolicyRequest(config: TidePolicyConfig, context: TideContextMethods): Promise<any>;
+/**
+ * Creates a policy creation handler that uses the Tide workflow.
+ * This is used as the default onCreatePolicy in RolesPage when Tide libs are available.
+ *
+ * @param context - TideCloak context methods
+ * @param onRequestCreated - Optional callback when request is created (for custom handling)
+ * @returns Policy creation handler function
+ */
+declare function createTidePolicyHandler(context: TideContextMethods, onRequestCreated?: (request: any, roleName: string) => Promise<void>): (params: {
+    roleName: string;
+    policyConfig: any;
+    templateId?: string;
+    templateParams?: Record<string, any>;
+    threshold: number;
+    contractCode?: string;
+}) => Promise<any>;
+/**
+ * Converts a RolePolicy to TidePolicyConfig.
+ * Useful when loading existing policies for re-signing or updates.
+ */
+declare function rolePolicyToTideConfig(policy: RolePolicy, context: TideContextMethods): TidePolicyConfig;
+
+type AdminAPIInstance$2 = {
+    setRealm?: (realm: string) => void;
+    getRoles: () => Promise<any>;
+    createRole: (role: any) => Promise<any>;
+    updateRole: (roleName: string, role: any) => Promise<any>;
+    deleteRole: (roleName: string) => Promise<any>;
+    getClientRoles?: (clientId?: string) => Promise<any>;
+    createClientRole?: (role: any, clientId?: string) => Promise<any>;
+    updateClientRole?: (roleName: string, role: any, clientId?: string) => Promise<any>;
+    deleteClientRole?: (roleName: string, clientId?: string) => Promise<any>;
+    getTemplates?: () => Promise<any>;
+    getUsers?: () => Promise<any>;
+    getPendingChangeSets?: () => Promise<any>;
+};
+interface RolePolicy {
+    roleName: string;
+    enabled: boolean;
+    contractType: string;
+    approvalType: "implicit" | "explicit";
+    executionType: "public" | "private";
+    threshold: number;
+    templateId?: string;
+    templateParams?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/** Implement this to store role policies (or use createLocalStoragePolicyAPI for dev) */
+interface PolicyAPI {
+    getPolicy: (roleName: string) => Promise<RolePolicy | null>;
+    upsertPolicy: (policy: RolePolicy) => Promise<RolePolicy | void>;
+    deletePolicy?: (roleName: string) => Promise<void>;
+    _isLocalStorage?: boolean;
+}
+/** localStorage adapter for development */
+declare function createLocalStoragePolicyAPI(storageKey?: string): PolicyAPI;
+interface RolesPageProps<T extends RoleItem = RoleItem> extends Omit<RolesPageBaseProps<T>, "fetchRoles" | "fetchTemplates" | "fetchUsers" | "fetchPendingApprovals" | "fetchRolePolicy" | "onCreate" | "onUpdate" | "onDelete" | "onCreatePolicy" | "toast" | "invalidateQueries" | "components" | "roleType"> {
+    /** AdminAPI instance */
+    adminAPI?: AdminAPIInstance$2;
+    /** Template adapter for policy templates */
+    templateAPI?: TemplateAPI;
+    /** Policy storage adapter */
+    policyAPI?: PolicyAPI;
+    /** Policy logs adapter for activity tracking */
+    policyLogsAPI?: PolicyLogsAPI;
+    /** Tide context for enclave workflow (from useTideCloak hook) */
+    tideContext?: TideContextMethods;
+    /** Callback when Tide policy request is created */
+    onTideRequestCreated?: (request: any, roleName: string) => Promise<void>;
+    /** Realm name */
+    realm?: string;
+    /** Role type: 'realm', 'client', or 'all' (default: 'realm') */
+    roleType?: RoleTypeConfig;
+    /** Override fetch roles */
+    fetchRoles?: RolesPageBaseProps<T>["fetchRoles"];
+    /** Override create */
+    onCreate?: RolesPageBaseProps<T>["onCreate"];
+    /** Override update */
+    onUpdate?: RolesPageBaseProps<T>["onUpdate"];
+    /** Override delete */
+    onDelete?: RolesPageBaseProps<T>["onDelete"];
+    /** Override policy creation */
+    onCreatePolicy?: RolesPageBaseProps<T>["onCreatePolicy"];
+    /** Toast handler */
+    toast?: RolesPageBaseProps<T>["toast"];
+    /** Query invalidation */
+    invalidateQueries?: RolesPageBaseProps<T>["invalidateQueries"];
+    /** Custom components */
+    components?: RolesPageBaseProps<T>["components"];
+    /** Help text below description */
+    helpText?: RolesPageBaseProps<T>["helpText"];
+    /** Current username for logging */
+    currentUsername?: string;
+}
+declare function RolesPage<T extends RoleItem = RoleItem>({ adminAPI: adminAPIProp, templateAPI, policyAPI, policyLogsAPI, tideContext, onTideRequestCreated, realm, roleType, fetchRoles: fetchRolesProp, onCreate: onCreateProp, onUpdate: onUpdateProp, onDelete: onDeleteProp, onCreatePolicy: onCreatePolicyProp, helpText: helpTextProp, currentUsername, ...props }: RolesPageProps<T>): react_jsx_runtime.JSX.Element;
+
+type AdminAPIInstance$1 = {
+    setRealm?: (realm: string) => void;
+    getPendingChangeSets: () => Promise<any>;
+    approveChangeSet: (changeSet: any) => Promise<any>;
+    commitChangeSet: (changeSet: any) => Promise<any>;
+    cancelChangeSet: (changeSet: any) => Promise<any>;
+    getRawChangeSetRequest?: (changeSet: any) => Promise<any[]>;
+    approveChangeSetWithSignature?: (changeSet: any, signedRequest: string) => Promise<void>;
+};
+interface TideApprovalResult {
+    id: string;
+    approved?: {
+        request: Uint8Array;
+    };
+    denied?: boolean;
+    pending?: boolean;
+}
+/** Get from useTideCloak() hook */
+interface TideApprovalContext {
+    initializeTideRequest: <T extends {
+        encode: () => Uint8Array;
+    }>(request: T) => Promise<T>;
+    approveTideRequests: (requests: {
+        id: string;
+        request: Uint8Array;
+    }[]) => Promise<TideApprovalResult[]>;
+}
+interface PolicyApprovalData {
+    id: string;
+    roleId: string;
+    requestedBy: string;
+    requestedByEmail?: string;
+    threshold: number;
+    approvalCount: number;
+    rejectionCount?: number;
+    commitReady?: boolean;
+    approvedBy?: string[];
+    deniedBy?: string[];
+    status: string;
+    timestamp: string | number;
+    policyRequestData: string;
+    contractCode?: string;
+}
+/** Implement this to store policy approvals (or use createLocalStoragePolicyApprovalsAPI for dev) */
+interface PolicyApprovalsAPI {
+    getPendingPolicies: () => Promise<PolicyApprovalData[]>;
+    approve?: (id: string, rejected?: boolean, username?: string) => Promise<void>;
+    revoke?: (id: string, username?: string) => Promise<void>;
+    commit?: (id: string) => Promise<void>;
+    cancel?: (id: string) => Promise<void>;
+    _isLocalStorage?: boolean;
+}
+/** localStorage adapter for development */
+declare function createLocalStoragePolicyApprovalsAPI(storageKey?: string): PolicyApprovalsAPI;
+interface AccessMetadataRecord {
+    changeSetId: string;
+    username: string;
+    userEmail?: string;
+    clientId?: string;
+    role?: string;
+    timestamp: string | number;
+    actionType?: string;
+    changeSetType?: string;
+}
+/** Implement this to store access change metadata (or use createLocalStorageAccessMetadataAPI for dev) */
+interface AccessMetadataAPI {
+    getMetadata: (changeSetId: string) => Promise<AccessMetadataRecord | null>;
+    getAllMetadata: () => Promise<AccessMetadataRecord[]>;
+    saveMetadata: (record: AccessMetadataRecord) => Promise<void>;
+    deleteMetadata: (changeSetId: string) => Promise<void>;
+    _isLocalStorage?: boolean;
+}
+/** localStorage adapter for development */
+declare function createLocalStorageAccessMetadataAPI(storageKey?: string): AccessMetadataAPI;
+/** Tab config with optional enclave support */
+interface EnclaveApprovalTabConfig {
+    /** Get raw request bytes for enclave approval (enables enclave if provided) */
+    getRawRequest?: (item: any) => Promise<Uint8Array | null>;
+    /** Submit signed approval after user approves in enclave */
+    submitSignedApproval?: (item: any, signedRequest: string) => Promise<void>;
+    /** Handle denial from enclave */
+    onEnclaveDenied?: (item: any) => Promise<void>;
+}
+interface ApprovalsPageProps extends Omit<ApprovalsPageBaseProps, "tabs"> {
+    /** AdminAPI instance */
+    adminAPI?: AdminAPIInstance$1;
+    /** Policy approvals storage adapter */
+    policyApprovalsAPI?: PolicyApprovalsAPI;
+    /** Policy logs adapter for activity tracking */
+    policyLogsAPI?: PolicyLogsAPI;
+    /** Access metadata adapter (merges with AdminAPI data) */
+    accessMetadataAPI?: AccessMetadataAPI;
+    /** Tide context for enclave approvals (from useTideCloak hook) */
+    tideContext?: TideApprovalContext;
+    /** Realm name */
+    realm?: string;
+    /** Custom tabs config */
+    tabs?: ApprovalsPageBaseProps["tabs"];
+    /** Additional tabs with optional enclave support */
+    additionalTabs?: (ApprovalTabConfig<BaseApprovalItem> & EnclaveApprovalTabConfig)[];
+    /** Show policy tab (default: true) */
+    showPolicyTab?: boolean;
+    /** Help text below description */
+    helpText?: ApprovalsPageBaseProps["helpText"];
+    /** Current username for logging */
+    currentUsername?: string;
+}
+declare function ApprovalsPage({ adminAPI: adminAPIProp, policyApprovalsAPI: policyApprovalsAPIProp, policyLogsAPI, accessMetadataAPI: accessMetadataAPIProp, tideContext, realm, tabs: tabsProp, additionalTabs, showPolicyTab, helpText: helpTextProp, currentUsername, ...props }: ApprovalsPageProps): react_jsx_runtime.JSX.Element;
+
+type AdminAPIInstance = {
+    setRealm?: (realm: string) => void;
+    getUsers: () => Promise<any>;
+    getRoles: () => Promise<any>;
+    getRole: (roleName: string) => Promise<any>;
+    createUser: (user: any) => Promise<any>;
+    updateUser: (userId: string, user: any) => Promise<any>;
+    deleteUser: (userId: string) => Promise<any>;
+    addUserRoles?: (userId: string, roles: any[]) => Promise<any>;
+    removeUserRoles?: (userId: string, roles: any[]) => Promise<any>;
+    setUserEnabled?: (userId: string, enabled: boolean) => Promise<any>;
+    getTideLinkUrl?: (userId: string, redirectUri: string, lifespan?: number) => Promise<string>;
+};
+interface ChangeSetInfo {
+    changeSetId: string;
+    changeSetType: string;
+    actionType: string;
+    username: string;
+    userId: string;
+    roles: string[];
+    timestamp: number;
+}
+interface UsersPageProps<T extends UserItem = UserItem> extends Omit<UsersPageBaseProps<T>, "fetchUsers" | "fetchRoles" | "onCreate" | "onUpdateProfile" | "onUpdateRoles" | "onDelete" | "onSetEnabled" | "getTideLinkUrl"> {
+    /** AdminAPI instance */
+    adminAPI?: AdminAPIInstance;
+    /** Realm name */
+    realm?: string;
+    /** Redirect URI for Tide link */
+    tideLinkRedirectUri?: string;
+    /** Access metadata adapter (saves metadata when role changes create change sets) */
+    accessMetadataAPI?: AccessMetadataAPI;
+    /** Callback when a change set is created */
+    onChangeSetCreated?: (info: ChangeSetInfo) => void | Promise<void>;
+    /** Override fetch users */
+    fetchUsers?: UsersPageBaseProps<T>["fetchUsers"];
+    /** Override create */
+    onCreate?: UsersPageBaseProps<T>["onCreate"];
+    /** Override delete */
+    onDelete?: UsersPageBaseProps<T>["onDelete"];
+    /** Override getTideLinkUrl */
+    getTideLinkUrl?: UsersPageBaseProps<T>["getTideLinkUrl"];
+}
+declare function UsersPage<T extends UserItem = UserItem>({ adminAPI: adminAPIProp, realm, tideLinkRedirectUri, accessMetadataAPI, onChangeSetCreated, fetchUsers: fetchUsersProp, onCreate: onCreateProp, onDelete: onDeleteProp, getTideLinkUrl: getTideLinkUrlProp, ...props }: UsersPageProps<T>): react_jsx_runtime.JSX.Element;
+
+declare function Card({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardContent({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function CardDescription({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    size?: "default" | "sm" | "lg" | "icon";
+}
+declare function Button({ children, variant, size, style, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    variant?: "default" | "secondary" | "destructive" | "outline";
+}
+declare function Badge({ children, variant, style, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare function Input({ className, style, ...props }: React$1.InputHTMLAttributes<HTMLInputElement>): react_jsx_runtime.JSX.Element;
+declare function Label({ children, className, style, ...props }: React$1.LabelHTMLAttributes<HTMLLabelElement>): react_jsx_runtime.JSX.Element;
+declare function Textarea({ className, style, ...props }: React$1.TextareaHTMLAttributes<HTMLTextAreaElement>): react_jsx_runtime.JSX.Element;
+interface CheckboxProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare function Checkbox({ onCheckedChange, onChange, style, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+declare function Select({ children, onValueChange, value, ...props }: {
+    children: React$1.ReactNode;
+    onValueChange?: (value: string) => void;
+    value?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function SelectTrigger({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function SelectValue({ placeholder }: {
+    placeholder?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function SelectContent({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element | null;
+declare function SelectItem({ children, value, style, ...props }: React$1.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+}): react_jsx_runtime.JSX.Element;
+declare function Skeleton({ className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function Table({ children, style, ...props }: React$1.HTMLAttributes<HTMLTableElement>): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ children, style, ...props }: React$1.HTMLAttributes<HTMLTableSectionElement>): react_jsx_runtime.JSX.Element;
+declare function TableBody({ children, style, ...props }: React$1.HTMLAttributes<HTMLTableSectionElement>): react_jsx_runtime.JSX.Element;
+declare function TableRow({ children, style, ...props }: React$1.HTMLAttributes<HTMLTableRowElement>): react_jsx_runtime.JSX.Element;
+declare function TableHead({ children, style, ...props }: React$1.ThHTMLAttributes<HTMLTableCellElement>): react_jsx_runtime.JSX.Element;
+declare function TableCell({ children, style, ...props }: React$1.TdHTMLAttributes<HTMLTableCellElement>): react_jsx_runtime.JSX.Element;
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React$1.ReactNode;
+}
+declare function Dialog({ open, onOpenChange, children }: DialogProps): react_jsx_runtime.JSX.Element | null;
+declare function DialogContent({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogHeader({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ children, style, ...props }: React$1.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ children, style, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface TabsProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    children: React$1.ReactNode;
+}
+declare function Tabs({ value, defaultValue, onValueChange, children }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ children, value, style, ...props }: React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ children, value, style, ...props }: React$1.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare function AlertDialog({ open, onOpenChange, children }: {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function AlertDialogContent({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogHeader({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogTitle({ children, style, ...props }: React$1.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogDescription({ children, style, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogFooter({ children, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogCancel({ children, style, onClick, ...props }: React$1.ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogAction({ children, style, onClick, ...props }: React$1.ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+interface SwitchProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    style?: React$1.CSSProperties;
+}
+declare function Switch({ checked, onCheckedChange, disabled, style }: SwitchProps): react_jsx_runtime.JSX.Element;
+declare function ScrollArea({ children, className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    variant?: "default" | "destructive";
+}
+declare function Alert({ children, variant, style, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ children, style, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+interface CodeEditorProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    height?: string;
+    style?: React$1.CSSProperties;
+}
+declare function CodeEditor({ value, onChange, height, style }: CodeEditorProps): react_jsx_runtime.JSX.Element;
+declare function Separator({ className, style, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare const defaultComponents: {
+    Card: typeof Card;
+    CardContent: typeof CardContent;
+    CardHeader: typeof CardHeader;
+    CardTitle: typeof CardTitle;
+    CardDescription: typeof CardDescription;
+    Button: typeof Button;
+    Badge: typeof Badge;
+    Input: typeof Input;
+    Label: typeof Label;
+    Textarea: typeof Textarea;
+    Checkbox: typeof Checkbox;
+    Select: typeof Select;
+    SelectTrigger: typeof SelectTrigger;
+    SelectValue: typeof SelectValue;
+    SelectContent: typeof SelectContent;
+    SelectItem: typeof SelectItem;
+    Skeleton: typeof Skeleton;
+    Switch: typeof Switch;
+    ScrollArea: typeof ScrollArea;
+    Alert: typeof Alert;
+    AlertDescription: typeof AlertDescription;
+    CodeEditor: typeof CodeEditor;
+    Table: typeof Table;
+    TableHeader: typeof TableHeader;
+    TableBody: typeof TableBody;
+    TableRow: typeof TableRow;
+    TableHead: typeof TableHead;
+    TableCell: typeof TableCell;
+    Dialog: typeof Dialog;
+    DialogContent: typeof DialogContent;
+    DialogHeader: typeof DialogHeader;
+    DialogTitle: typeof DialogTitle;
+    DialogDescription: typeof DialogDescription;
+    DialogFooter: typeof DialogFooter;
+    AlertDialog: typeof AlertDialog;
+    AlertDialogContent: typeof AlertDialogContent;
+    AlertDialogHeader: typeof AlertDialogHeader;
+    AlertDialogTitle: typeof AlertDialogTitle;
+    AlertDialogDescription: typeof AlertDialogDescription;
+    AlertDialogFooter: typeof AlertDialogFooter;
+    AlertDialogCancel: typeof AlertDialogCancel;
+    AlertDialogAction: typeof AlertDialogAction;
+    Separator: typeof Separator;
+    Tabs: typeof Tabs;
+    TabsList: typeof TabsList;
+    TabsTrigger: typeof TabsTrigger;
+    TabsContent: typeof TabsContent;
+};
+
+export { ACTION_COLORS, ACTION_ICONS, type AccessApprovalItem, type AccessLogItem, type AccessMetadataAPI, type AccessMetadataRecord, ActionButton, ActionButtonGroup, type ActionButtonGroupProps, type ActionButtonProps, type ActionResult, type ActionType, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, type ApprovableItem, type ApprovalDecision, type ApprovalStatus, type ApprovalTabConfig, ApprovalsPage, ApprovalsPageBase, type ApprovalsPageBaseProps, type ApprovalsPageProps, type AsyncActionHandler, type AutoRefreshOptions, type AutoRefreshReturn, Badge, type BadgeConfig, type BaseApprovalItem, type BaseDataItem, type BaseLogItem, type BulkAction, Button, Card, CardContent, CardDescription, CardHeader, CardTitle, type ChangeSetInfo, type ChangeSetRequest, Checkbox, CodeEditor, CodePreview, CollapsibleSection, type CollapsibleSectionProps, type ColumnDef, ConfirmDialog, type ConfirmDialogConfig, type ConfirmDialogProps, type CreateUserFormData, DEFAULT_MODEL_IDS, DEFAULT_ROLE_CONTRACT, DataTable, type DataTableProps, DetailDialog, type DetailDialogProps, type DetailField, Dialog, type DialogConfig, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, EmptyState, type EmptyStateConfig, EmptyStateNoData, EmptyStateNoFiles, EmptyStateNoResults, type EmptyStateProps, type EnclaveApprovalTabConfig, type FormFieldDef, type FormFieldType, type FrameworkConfig, Input, Label, LoadingSkeleton, type LoadingSkeletonProps, type LoadingStateConfig, LogsPage, LogsPageBase, type LogsPageBaseProps, type LogsPageProps, type LogsTabConfig, type PageSizeMode, PaginatedTable, type PaginatedTableProps, type PaginationConfig, type PaginationReturn, type ParameterDef, type PolicyAPI, type PolicyApprovalData, type PolicyApprovalItem, type PolicyApprovalsAPI, type PolicyConfig, type PolicyLogData, type PolicyLogItem, type PolicyLogsAPI, type PolicyTemplateItem$1 as PolicyTemplateItem, type RawApprovalRequest, RefreshButton, type RefreshButtonProps, type RoleApprovalItem, type RoleItem, type RolePolicy, type PolicyTemplateItem as RolePolicyTemplateItem, type TemplateParameter as RoleTemplateParameter, RolesPage, RolesPageBase, type RolesPageBaseProps, type RolesPageProps, STATUS_COLORS, STATUS_ICONS, ScrollArea, Select, SelectContent, SelectItem, type SelectOption, SelectTrigger, SelectValue, type SelectionReturn, Separator, type SignedApprovalResponse, Skeleton$1 as Skeleton, type SkeletonProps, type SortConfig, StatusBadge, type StatusBadgeProps, type StatusConfig, type StatusType, Switch, type TabDef, Table, type TableAction, TableBody, TableCell, TableHead, TableHeader, TableRow, TableRowSkeleton, Tabs, TabsContent, TabsList, TabsTrigger, TabsView, type TabsViewProps, type TemplateAPI, type TemplateFormData, type TemplateParameter$1 as TemplateParameter, TemplatesPage, TemplatesPageBase, type TemplatesPageBaseProps, type TemplatesPageProps, Textarea, type TideApprovalContext, type TideApprovalResult, type TideContextMethods, type TidePolicyConfig, type ToastConfig, Skeleton as UIComponentSkeleton, type UsePaginationOptions, type UserFormData, type UserItem, type RoleItem$1 as UserRoleItem, UsersPage, UsersPageBase, type UsersPageBaseProps, type UsersPageProps, areTideLibsAvailable, base64ToBytes, bytesToBase64, cn, colors, computeContractId, computeRowsForViewportHeight, createActionColumn, createLocalStorageAccessMetadataAPI, createLocalStoragePolicyAPI, createLocalStoragePolicyApprovalsAPI, createLocalStoragePolicyLogsAPI, createLocalStorageTemplateAPI, createLogProgressColumn, createLogTimestampColumn, createProgressColumn, createRoleColumn, createStatusColumn, createTidePolicyHandler, createTidePolicyRequest, createTimestampColumn, createUserColumn, defaultComponents, delay, duration, focusRing, fontSize, formatLogTimestamp, formatTimestamp, generateId, getStatusConfig, injectThemeCSS, isDefined, loadTideLibs, radius, rolePolicyToTideConfig, safeJsonParse, shadow, spacing, themeCSS, truncate, useAutoRefresh, usePagination, useSelection, zIndex };