forlogic-core 2.2.7 → 2.3.0

package/dist/audit-trail/components/dashboards/dashboard-form.d.ts

@@ -0,0 +1,65 @@
+import { type Dashboard, DashboardFormTab, DashboardShareType, DashboardUpdateTime, DashboardViewType, DashboardPageTime } from './types';
+/**
+ * Tipo `DashboardFormValues` exportado pela lib.
+ * @example
+ * const value: DashboardFormValues = {} as DashboardFormValues;
+ */
+export interface DashboardFormValues {
+    titlePtBr: string;
+    titleEnUs: string;
+    titleEsEs: string;
+    responsibleId?: string;
+    isActive: boolean;
+    idUpdateTime: DashboardUpdateTime;
+    idViewType: DashboardViewType;
+    idPageTime: DashboardPageTime | null;
+    idShare: DashboardShareType;
+    groups?: string[];
+    places?: string[];
+    collaborators?: string[];
+}
+/**
+ * Tipo `DashboardFormProps` exportado pela lib.
+ * @example
+ * const value: DashboardFormProps = {} as DashboardFormProps;
+ */
+export interface DashboardFormProps {
+    /** Existing dashboard for editing; null for creation */
+    dashboard?: Dashboard | null;
+    /** Initial tab (General or Share) */
+    initialTab?: DashboardFormTab;
+    /** Whether saving is in progress */
+    isSaving?: boolean;
+    /** Whether this is a "Qualitfy" standard dashboard (locks some fields) */
+    isQualitfy?: boolean;
+    /** Users list for owner selector */
+    users?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Groups list for share section */
+    groups?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Places list for share section */
+    places?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Collaborators list for share section */
+    collaborators?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Callbacks */
+    onSave?: (values: DashboardFormValues) => void;
+    onCancel?: () => void;
+    className?: string;
+}
+/**
+ * Função utilitária `DashboardForm`.
+ * @example
+ * DashboardForm();
+ */
+export declare function DashboardForm({ dashboard, initialTab, isSaving, isQualitfy, users, groups, places, collaborators, onSave, onCancel, className, }: DashboardFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/dashboard-general-view.d.ts

@@ -0,0 +1,124 @@
+import { type ReactNode } from 'react';
+import { type Dashboard, type DashboardPanel, type DashboardPage, type DashboardLimit, type GeneralViewDashboard, DashboardLanguage, QuickFilterDashboard } from './types';
+import { type DashboardFormValues } from './dashboard-form';
+import { type GridPanelLayout } from './dashboard-grid';
+import { type DashboardPanelRendererProps } from './dashboard-panel-renderer';
+/**
+ * Tipo `DashboardViewState` exportado pela lib.
+ * @example
+ * const value: DashboardViewState = {} as DashboardViewState;
+ */
+export type DashboardViewState = {
+    mode: 'list';
+} | {
+    mode: 'view';
+    dashboardId: string;
+} | {
+    mode: 'create';
+} | {
+    mode: 'edit';
+    dashboardId: string;
+} | {
+    mode: 'share';
+    dashboardId: string;
+};
+/**
+ * Tipo `DashboardGeneralViewProps` exportado pela lib.
+ * @example
+ * const value: DashboardGeneralViewProps = {} as DashboardGeneralViewProps;
+ */
+export interface DashboardGeneralViewProps {
+    /** All dashboards for the list */
+    dashboards: Dashboard[];
+    /** Usage limits */
+    limit?: DashboardLimit;
+    /** General view config (default dashboard per software) */
+    generalView?: GeneralViewDashboard | null;
+    /** Current language */
+    language?: DashboardLanguage;
+    /** Whether the list/data is loading */
+    isLoading?: boolean;
+    canAdd?: boolean;
+    canEdit?: boolean;
+    canRemove?: boolean;
+    canEditStandard?: boolean;
+    /** Panels for the currently opened dashboard */
+    activePanels?: DashboardPanel[];
+    /** Pages for the currently opened dashboard (carousel mode) */
+    activePages?: DashboardPage[];
+    /** Per-panel data provider */
+    getPanelData?: (panelId: string) => Omit<DashboardPanelRendererProps, 'config'>;
+    /** Users for owner selector in form */
+    users?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Groups for sharing */
+    groups?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Places for sharing */
+    places?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Collaborators for sharing */
+    collaborators?: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Whether the form is saving */
+    isSaving?: boolean;
+    /** Called when a dashboard is opened for viewing */
+    onOpen?: (dashboard: Dashboard) => void;
+    /** Called when navigating back to list */
+    onBackToList?: () => void;
+    /** Called to refresh the current dashboard data */
+    onRefresh?: () => void;
+    /** Called to refresh the dashboard list */
+    onRefreshList?: () => void;
+    /** Called on toggling favorite */
+    onToggleFavorite?: (dashboard: Dashboard) => void;
+    /** Called when creating a new dashboard */
+    onSave?: (values: DashboardFormValues) => void;
+    /** Called when updating an existing dashboard */
+    onUpdate?: (dashboardId: string, values: DashboardFormValues) => void;
+    /** Called to remove a dashboard */
+    onRemove?: (dashboard: Dashboard) => void;
+    /** Called to duplicate a dashboard */
+    onDuplicate?: (dashboard: Dashboard) => void;
+    /** Called when sharing a dashboard */
+    onShare?: (dashboard: Dashboard) => void;
+    /** Called on panel add */
+    onAddPanel?: () => void;
+    /** Called on panel edit */
+    onEditPanel?: (panelId: string) => void;
+    /** Called on panel remove */
+    onRemovePanel?: (panelId: string) => void;
+    /** Called on panel duplicate */
+    onDuplicatePanel?: (panelId: string) => void;
+    /** Called when layout changes via DnD */
+    onLayoutChange?: (panels: GridPanelLayout[]) => void;
+    /** Called when search text changes in the list */
+    onSearch?: (search: string) => void;
+    /** Called when quick filter changes */
+    onQuickFilterChange?: (filter: QuickFilterDashboard) => void;
+    /** Called to set as general view */
+    onSetGeneralView?: (dashboardId: string) => void;
+    /** Controlled view state (optional — component manages its own state if not provided) */
+    viewState?: DashboardViewState;
+    /** Called when view state changes (for controlled mode) */
+    onViewStateChange?: (state: DashboardViewState) => void;
+    /** Custom toolbar actions for the list view */
+    listToolbarExtra?: ReactNode;
+    /** Custom toolbar actions for the dashboard view */
+    viewToolbarActions?: ReactNode;
+    className?: string;
+}
+/**
+ * Função utilitária `DashboardGeneralView`.
+ * @example
+ * DashboardGeneralView();
+ */
+export declare function DashboardGeneralView({ dashboards, limit, generalView, language, isLoading, canAdd, canEdit, canRemove, canEditStandard, activePanels, activePages, getPanelData, users, groups, places, collaborators, isSaving, onOpen, onBackToList, onRefresh, onRefreshList, onToggleFavorite, onSave, onUpdate, onRemove, onDuplicate, onShare, onAddPanel, onEditPanel, onRemovePanel, onDuplicatePanel, onLayoutChange, onSearch, onQuickFilterChange, onSetGeneralView, viewState: controlledViewState, onViewStateChange, listToolbarExtra, viewToolbarActions, className, }: DashboardGeneralViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/dashboard-grid.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from 'react';
+import { DashboardPanelType } from './types';
+/**
+ * Tipo `GridPanelLayout` exportado pela lib.
+ * @example
+ * const value: GridPanelLayout = {} as GridPanelLayout;
+ */
+export interface GridPanelLayout {
+    id: string;
+    col: number;
+    row: number;
+    sizeX: number;
+    sizeY: number;
+    minSizeX?: number;
+    minSizeY?: number;
+}
+/**
+ * Tipo `DashboardGridProps` exportado pela lib.
+ * @example
+ * const value: DashboardGridProps = {} as DashboardGridProps;
+ */
+export interface DashboardGridProps {
+    /**
+     * Panel layout definitions. Each panel gets positioned in an 8-column grid.
+     */
+    panels: GridPanelLayout[];
+    /** Number of grid columns (default: 8, matching legacy) */
+    columns?: number;
+    /** Cell height in pixels (default: 160) */
+    cellHeight?: number;
+    /** Gap between cells in pixels (default: 10) */
+    cellGap?: number;
+    /** Allow drag-and-drop reordering */
+    allowDragging?: boolean;
+    /** Show grid lines behind panels */
+    showGridLines?: boolean;
+    /** Render the content for each panel */
+    renderPanel: (panelId: string) => ReactNode;
+    /** Called after drag completes with the new order of panel IDs */
+    onLayoutChange?: (panels: GridPanelLayout[]) => void;
+    className?: string;
+}
+/**
+ * Função utilitária `getDefaultPanelSize`.
+ * @example
+ * getDefaultPanelSize();
+ */
+export declare function getDefaultPanelSize(panelType: DashboardPanelType): {
+    x: number;
+    y: number;
+};
+/**
+ * Função utilitária `getMinPanelSize`.
+ * @example
+ * getMinPanelSize();
+ */
+export declare function getMinPanelSize(panelType: DashboardPanelType): {
+    x: number;
+    y: number;
+};
+/**
+ * Função utilitária `DashboardGrid`.
+ * @example
+ * DashboardGrid();
+ */
+export declare function DashboardGrid({ panels, columns, cellHeight, cellGap, allowDragging, showGridLines, renderPanel, onLayoutChange, className, }: DashboardGridProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/dashboard-list.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from 'react';
+import { type Dashboard, type DashboardLimit, QuickFilterDashboard, DashboardLanguage } from './types';
+/**
+ * Tipo `DashboardListProps` exportado pela lib.
+ * @example
+ * const value: DashboardListProps = {} as DashboardListProps;
+ */
+export interface DashboardListProps {
+    /** List of dashboards to display */
+    dashboards: Dashboard[];
+    /** Dashboard usage limits */
+    limit?: DashboardLimit;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Current user language for title resolution */
+    language?: DashboardLanguage;
+    /** Permissions */
+    canAdd?: boolean;
+    canEdit?: boolean;
+    canRemove?: boolean;
+    /** Callbacks */
+    onOpen?: (dashboard: Dashboard) => void;
+    onEdit?: (dashboard: Dashboard) => void;
+    onShare?: (dashboard: Dashboard) => void;
+    onDuplicate?: (dashboard: Dashboard) => void;
+    onRemove?: (dashboard: Dashboard) => void;
+    onAdd?: () => void;
+    onToggleFavorite?: (dashboard: Dashboard) => void;
+    onRefresh?: () => void;
+    onSearch?: (search: string) => void;
+    onQuickFilterChange?: (filter: QuickFilterDashboard) => void;
+    /** Custom toolbar actions */
+    toolbarExtra?: ReactNode;
+    className?: string;
+}
+/**
+ * Função utilitária `DashboardList`.
+ * @example
+ * DashboardList();
+ */
+export declare function DashboardList({ dashboards, limit, isLoading, language, canAdd, canEdit, canRemove, onOpen, onEdit, onShare, onDuplicate, onRemove, onAdd, onToggleFavorite, onRefresh, onSearch, onQuickFilterChange, toolbarExtra, className, }: DashboardListProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/dashboard-panel-renderer.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+import { type PanelConfig, type PanelResult, PanelState } from './types';
+import { type ListPanelColumn, type BurndownDataPoint, type PerformanceDataPoint, type MatrixRule, type MatrixRisk, type CartesianSeries } from './panels';
+/**
+ * Tipo `DashboardPanelRendererProps` exportado pela lib.
+ * @example
+ * const value: DashboardPanelRendererProps = {} as DashboardPanelRendererProps;
+ */
+export interface DashboardPanelRendererProps {
+    config: PanelConfig;
+    state: PanelState;
+    data?: PanelResult[];
+    /** Numeric panel value */
+    numericValue?: number | string | null;
+    /** Extra data for specialized panels */
+    listColumns?: ListPanelColumn[];
+    cartesianData?: Record<string, unknown>[];
+    cartesianSeries?: CartesianSeries[];
+    burndownData?: BurndownDataPoint[];
+    performanceData?: PerformanceDataPoint[];
+    matrixRule?: MatrixRule;
+    matrixRisks?: MatrixRisk[];
+    /** Callbacks */
+    onPanelClick?: (data: Record<string, unknown>) => void;
+}
+/**
+ * Função utilitária `DashboardPanelRenderer`.
+ * @example
+ * DashboardPanelRenderer();
+ */
+export declare function DashboardPanelRenderer({ config, state, data, numericValue, listColumns, cartesianData, cartesianSeries, burndownData, performanceData, matrixRule, matrixRisks, onPanelClick, }: DashboardPanelRendererProps): ReactNode;

package/dist/audit-trail/components/dashboards/dashboard-view.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from 'react';
+import { type Dashboard, type DashboardPage, type DashboardPanel } from './types';
+import { type GridPanelLayout } from './dashboard-grid';
+import { type DashboardPanelRendererProps } from './dashboard-panel-renderer';
+/**
+ * Tipo `DashboardViewProps` exportado pela lib.
+ * @example
+ * const value: DashboardViewProps = {} as DashboardViewProps;
+ */
+export interface DashboardViewProps {
+    /** Dashboard metadata */
+    dashboard: Dashboard;
+    /** Panels to render */
+    panels: DashboardPanel[];
+    /** Pages (for carousel mode) */
+    pages?: DashboardPage[];
+    /** Current active page ID (carousel mode) */
+    activePageId?: string;
+    /** Allow editing (drag, resize, add, remove) */
+    canEdit?: boolean;
+    /** Fullscreen mode */
+    isFullscreen?: boolean;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Per-panel data provider: return panel-specific data for rendering */
+    getPanelData?: (panelId: string) => Omit<DashboardPanelRendererProps, 'config'>;
+    /** Callbacks */
+    onRefresh?: () => void;
+    onToggleFullscreen?: () => void;
+    onToggleFavorite?: () => void;
+    onEdit?: () => void;
+    onShare?: () => void;
+    onAddPanel?: () => void;
+    onEditPanel?: (panelId: string) => void;
+    onRemovePanel?: (panelId: string) => void;
+    onDuplicatePanel?: (panelId: string) => void;
+    onLayoutChange?: (panels: GridPanelLayout[]) => void;
+    onPageChange?: (pageId: string) => void;
+    /** Custom toolbar actions */
+    toolbarActions?: ReactNode;
+    className?: string;
+}
+/**
+ * Função utilitária `DashboardView`.
+ * @example
+ * DashboardView();
+ */
+export declare function DashboardView({ dashboard, panels, pages, activePageId, canEdit, isFullscreen, isLoading, getPanelData, onRefresh, onToggleFullscreen, onToggleFavorite, onEdit, onShare, onAddPanel, onEditPanel, onRemovePanel, onDuplicatePanel, onLayoutChange, onPageChange, toolbarActions, className, }: DashboardViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/helpers.d.ts

@@ -0,0 +1,86 @@
+import type { PanelResult, PlaceAnalysis } from './types';
+/** Month abbreviation → number (pt-BR) *
+ * @example
+ * <MONTHS_MAP />
+ */
+export declare const MONTHS_MAP: Record<string, number>;
+/** localStorage keys used by dashboard module *
+ * @example
+ * <DASHBOARD_STORAGE_KEYS />
+ */
+export declare const DASHBOARD_STORAGE_KEYS: {
+    readonly advancedFilter: "analysisDashboardsListFilter";
+};
+/** Fields known to contain currency values *
+ * @example
+ * <CURRENCY_FIELDS />
+ */
+export declare const CURRENCY_FIELDS: readonly ["total_calibration_cost", "total_verification_cost", "total_maintenance_cost", "last_calibration_cost", "last_verification_cost", "last_maintenance_cost", "total_cost", "total_reported_cost", "estimated_cost", "last_report_cost_reported_cost", "occurrence_reported_cost", "task_estimated_cost"];
+/** Properties that may contain a navigable link in a row *
+ * @example
+ * <LINK_PROPERTIES />
+ */
+export declare const LINK_PROPERTIES: readonly ["link", "link_risk", "risk_link", "link_group", "group_link", "link_occurrence", "occurrence_link", "link_audit", "link_project", "link_program", "link_ideia", "flow_link", "decision_link", "link_supplier", "auditing_link", "fmea_link"];
+/**
+ * Sort panel results by month/year date (pt-BR format: "jan/2024").
+ *
+ * @example
+ * sortByMonthYear();
+ */
+export declare function sortByMonthYear(dataSource: PanelResult[]): PanelResult[];
+/**
+ * Check if a field value is null, undefined, or an empty string.
+ *
+ * @example
+ * isNullOrEmptyField();
+ */
+export declare function isNullOrEmptyField(field: {
+    value?: string | null;
+} | null | undefined): boolean;
+/**
+ * Sanitize the last segment of a URL (title) by removing special chars and encoding.
+ *
+ * @example
+ * processUrl();
+ */
+export declare function processUrl(url: string): string;
+/**
+ * Get the first navigable link found in a row object.
+ *
+ * @example
+ * getLinkFromRow();
+ */
+export declare function getLinkFromRow(row: Record<string, unknown>): string | null;
+/**
+ * Serialize an object to query-string format (key=value&key=value).
+ *
+ * @example
+ * toQueryString();
+ */
+export declare function toQueryString(obj: Record<string, unknown> | null | undefined): string | null;
+/**
+ * Check if a string looks like a currency value.
+ *
+ * @example
+ * isCurrency();
+ */
+export declare function isCurrency(value: string): boolean;
+/**
+ * Extract a numeric value from a formatted currency string (pt-BR format).
+ *
+ * @example
+ * extractNumberFromCurrency();
+ */
+export declare function extractNumberFromCurrency(value: string): number;
+/** Pre-built pt-BR currency formatter *
+ * @example
+ * currencyFormatter;
+ */
+export declare const currencyFormatter: Intl.NumberFormat;
+/**
+ * Build a hierarchical tree from a flat list of places.
+ *
+ * @example
+ * buildPlacesTree();
+ */
+export declare function buildPlacesTree(places: PlaceAnalysis[]): PlaceAnalysis[];

package/dist/audit-trail/components/dashboards/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './helpers';
+export * from './panels';
+export { DashboardGrid, getDefaultPanelSize, getMinPanelSize, type GridPanelLayout, type DashboardGridProps } from './dashboard-grid';
+export { DashboardPanelRenderer, type DashboardPanelRendererProps } from './dashboard-panel-renderer';
+export { DashboardView, type DashboardViewProps } from './dashboard-view';
+export { DashboardList, type DashboardListProps } from './dashboard-list';
+export { DashboardForm, type DashboardFormProps, type DashboardFormValues } from './dashboard-form';
+export { DashboardGeneralView, type DashboardGeneralViewProps, type DashboardViewState } from './dashboard-general-view';

package/dist/audit-trail/components/dashboards/panels/burndown-panel.d.ts

@@ -0,0 +1,41 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+/**
+ * Tipo `BurndownDataPoint` exportado pela lib.
+ * @example
+ * const value: BurndownDataPoint = {} as BurndownDataPoint;
+ */
+export interface BurndownDataPoint {
+    date: string;
+    executedPercentage: number;
+    plannedPercentage: number;
+    tooltipExecuted?: string;
+    tooltipPlanned?: string;
+}
+/**
+ * Tipo `BurndownPanelProps` exportado pela lib.
+ * @example
+ * const value: BurndownPanelProps = {} as BurndownPanelProps;
+ */
+export interface BurndownPanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    data?: BurndownDataPoint[];
+    /** Labels for series */
+    executedLabel?: string;
+    plannedLabel?: string;
+    /** Colors */
+    executedColor?: string;
+    plannedColor?: string;
+    viewOnly?: boolean;
+    onRefresh?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+/**
+ * Função utilitária `BurndownPanel`.
+ * @example
+ * BurndownPanel();
+ */
+export declare function BurndownPanel({ config, state, data, executedLabel, plannedLabel, executedColor, plannedColor, viewOnly, onRefresh, queryUrl, queryUrlBuilder, className, }: BurndownPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/panels/cartesian-panel.d.ts

@@ -0,0 +1,66 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+/**
+ * Tipo `CartesianVariant` exportado pela lib.
+ * @example
+ * const value: CartesianVariant = {} as CartesianVariant;
+ */
+export type CartesianVariant = 'bar' | 'column' | 'stacked-column' | 'area' | 'line' | 'evolution-line';
+/**
+ * Tipo `CartesianSeries` exportado pela lib.
+ * @example
+ * const value: CartesianSeries = {} as CartesianSeries;
+ */
+export interface CartesianSeries {
+    /** Data key in each data point */
+    dataKey: string;
+    /** Display name in legend/tooltip */
+    name?: string;
+    /** Color override */
+    color?: string;
+    /** Stack ID for stacked charts */
+    stackId?: string;
+}
+/**
+ * Tipo `CartesianPanelProps` exportado pela lib.
+ * @example
+ * const value: CartesianPanelProps = {} as CartesianPanelProps;
+ */
+export interface CartesianPanelProps {
+    config: PanelConfig;
+    /** Chart variant to render */
+    variant: CartesianVariant;
+    /** Current state of the panel */
+    state: PanelState;
+    /**
+     * Transformed chart data — array of objects where each object is a data point.
+     * Must include a `name` or `key` field for the category axis.
+     */
+    data?: Record<string, unknown>[];
+    /**
+     * Series definitions. If omitted, a single series using `value` dataKey is assumed.
+     */
+    series?: CartesianSeries[];
+    /** Palette hex colors to use for series (from config or custom) */
+    colors?: string[];
+    /** Category axis data key (default: 'key') */
+    categoryKey?: string;
+    /** Y-axis label format (e.g. 'R$ {value}') */
+    yAxisFormat?: string;
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    /** Called when a data point is clicked */
+    onPointClick?: (data: Record<string, unknown>, index: number) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+/**
+ * Função utilitária `CartesianPanel`.
+ * @example
+ * CartesianPanel();
+ */
+export declare function CartesianPanel({ config, variant, state, data, series: seriesProp, colors: colorsProp, categoryKey, yAxisFormat, viewOnly, onPointClick, onRefresh, onExport, queryUrl, queryUrlBuilder, className, }: CartesianPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/dashboards/panels/index.d.ts

@@ -0,0 +1,14 @@
+export { PanelHeader, type PanelHeaderProps } from './panel-header';
+export { PanelError, type PanelErrorProps } from './panel-error';
+export { PanelLoader, type PanelLoaderProps } from './panel-loader';
+export { PanelNoData, type PanelNoDataProps } from './panel-no-data';
+export { PanelUnavailable, type PanelUnavailableProps } from './panel-unavailable';
+export { NumericPanel, type NumericPanelProps } from './numeric-panel';
+export { TextPanel, type TextPanelProps } from './text-panel';
+export { ListPanel, type ListPanelProps, type ListPanelColumn } from './list-panel';
+export { CartesianPanel, type CartesianPanelProps, type CartesianVariant, type CartesianSeries } from './cartesian-panel';
+export { PiePanel, type PiePanelProps } from './pie-panel';
+export { ParetoPanel, type ParetoPanelProps } from './pareto-panel';
+export { BurndownPanel, type BurndownPanelProps, type BurndownDataPoint } from './burndown-panel';
+export { PerformancePanel, type PerformancePanelProps, type PerformanceDataPoint } from './performance-panel';
+export { MatrixRiskPanel, type MatrixRiskPanelProps, type MatrixRule, type MatrixParameter, type MatrixRisk } from './matrix-risk-panel';

package/dist/audit-trail/components/dashboards/panels/list-panel.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig, type SelectedColumn } from '../types';
+/**
+ * Tipo `ListPanelColumn` exportado pela lib.
+ * @example
+ * const value: ListPanelColumn = {} as ListPanelColumn;
+ */
+export interface ListPanelColumn extends SelectedColumn {
+    /** Render function override for custom cell content */
+    render?: (value: unknown, row: Record<string, unknown>) => React.ReactNode;
+}
+/**
+ * Tipo `ListPanelProps` exportado pela lib.
+ * @example
+ * const value: ListPanelProps = {} as ListPanelProps;
+ */
+export interface ListPanelProps {
+    config: PanelConfig;
+    /** Current state of the panel */
+    state: PanelState;
+    /** Row data */
+    data?: Record<string, unknown>[];
+    /** Column definitions */
+    columns?: ListPanelColumn[];
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    /** Called when a row is clicked */
+    onRowClick?: (row: Record<string, unknown>) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    /** Query URL builder for header */
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    /** Whether to auto-navigate to row links on click */
+    enableRowLinks?: boolean;
+    className?: string;
+}
+/**
+ * Função utilitária `ListPanel`.
+ * @example
+ * ListPanel();
+ */
+export declare function ListPanel({ config, state, data, columns, viewOnly, onRowClick, onRefresh, onExport, queryUrl, queryUrlBuilder, enableRowLinks, className, }: ListPanelProps): import("react/jsx-runtime").JSX.Element;