forlogic-core 1.20.1 → 2.0.0

package/dist/approval-flow/components/ApprovalSidenav.d.ts

@@ -0,0 +1,16 @@
+import type { ApprovalSidenavConfig, ApproveDialogResult, ApproverOption } from '../types';
+interface ApprovalSidenavProps {
+    config: ApprovalSidenavConfig;
+    isLoading?: boolean;
+    onClose: () => void;
+    onApprove: (associationId: string, data: {
+        stepApproverId: string;
+    } & ApproveDialogResult) => Promise<boolean>;
+    onDefineApprover: (associationId: string, approverId: string, user: ApproverOption) => Promise<void>;
+    onRefreshSteps?: (associationId: string) => Promise<void>;
+    /** List of available approvers for the "select approver" dialog */
+    availableApprovers?: ApproverOption[];
+    isLoadingApprovers?: boolean;
+}
+export declare function ApprovalSidenav({ config, isLoading, onClose, onApprove, onDefineApprover, onRefreshSteps, availableApprovers, isLoadingApprovers, }: ApprovalSidenavProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/approval-flow/components/ApproveDialog.d.ts

@@ -0,0 +1,13 @@
+import type { ApprovalReturnStepOption, ApproveDialogResult } from '../types';
+interface ApproveDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    returnSteps: ApprovalReturnStepOption[];
+    initialObservation?: string;
+    title?: string;
+    descriptions?: string[];
+    setDefaultApproverOnInit?: boolean;
+    onSubmit: (result: ApproveDialogResult) => void;
+}
+export declare function ApproveDialog({ open, onOpenChange, returnSteps, initialObservation, title, descriptions, setDefaultApproverOnInit, onSubmit, }: ApproveDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/approval-flow/components/SelectApproverDialog.d.ts

@@ -0,0 +1,11 @@
+import type { ApproverOption } from '../types';
+interface SelectApproverDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    approvers: ApproverOption[];
+    isLoading?: boolean;
+    ignoreUserIds?: string[];
+    onSubmit: (approver: ApproverOption) => void;
+}
+export declare function SelectApproverDialog({ open, onOpenChange, approvers, isLoading, ignoreUserIds, onSubmit, }: SelectApproverDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/approval-flow/index.d.ts

@@ -0,0 +1,4 @@
+export { ApprovalSidenav } from './components/ApprovalSidenav';
+export { ApproveDialog } from './components/ApproveDialog';
+export { SelectApproverDialog } from './components/SelectApproverDialog';
+export * from './types';

package/dist/approval-flow/types.d.ts

@@ -0,0 +1,76 @@
+export declare enum ApprovalFlowReturnStep {
+    ApprovalFlow = 1,
+    Association = 2
+}
+/** Approver type: 1=User, 2=Group, 3=Place */
+export type ApproverType = 1 | 2 | 3;
+export interface ApprovalFlowInfo {
+    title?: string;
+    value: string;
+    icon?: string;
+    color?: string;
+    backgroundColor?: string;
+}
+export interface ApprovalFlowStepApprover {
+    id: string;
+    type: ApproverType;
+    name: string;
+    approverId: string;
+    identityId?: string;
+    approvedUsername?: string;
+    date?: Date | string;
+    observation?: string;
+    canApprove: boolean;
+    hasAccess: boolean;
+    returnObservation?: string;
+    returnDate?: Date | string;
+    returnUserId?: string;
+    photoUrl?: string;
+    readLess?: boolean;
+    isToBeDefined?: boolean;
+}
+export interface ApprovalFlowStep {
+    id: string;
+    name: string;
+    allApprove: boolean;
+    description?: string;
+    index: number;
+    isCurrentStep: boolean;
+    returnUserName?: string;
+    returnDate?: Date | string;
+    returnObservation?: string;
+    approvers: ApprovalFlowStepApprover[];
+    returnObservationReadLess?: boolean;
+    readLess?: boolean;
+}
+export interface ApprovalSidenavConfig {
+    associationId: string;
+    title: string;
+    color: string;
+    flowReproved: boolean;
+    returnSteps: ApprovalReturnStepOption[];
+    canApprove: boolean;
+    approvalFlowInfo: ApprovalFlowInfo[];
+    approvalFlowSteps: ApprovalFlowStep[];
+    approveDialogTitle?: string;
+    approveDialogDescriptions?: string[];
+    approveDialogSetDefaultApproverOnInit?: boolean;
+}
+export interface ApprovalReturnStepOption {
+    id: string;
+    name: string;
+    type: ApprovalFlowReturnStep;
+}
+export interface ApproveDialogResult {
+    approved: boolean;
+    returnStepId: string | null;
+    returnType: ApprovalFlowReturnStep | null;
+    observation: string;
+}
+export interface ApproverOption {
+    id: string;
+    name: string;
+    email?: string;
+    identityId?: number;
+    avatar?: string;
+}

package/dist/assets/index.d.ts

@@ -1,6 +1,7 @@
 export declare const assets: {
     logo: string;
     smallLogo: string;
+    favicon: string;
 };
 export declare const logoSrc: string;
 export declare const smallLogoSrc: string;

package/dist/audit-trail/components/AuditTrailDetails.d.ts

@@ -0,0 +1,17 @@
+/**
+ * AuditTrailDetails
+ * Drawer/panel showing detail rows for a selected audit trail entry
+ * Ported from flc-audit-trail-details (v2) and qex-audit-trail-readable-details (v1)
+ */
+import type { AuditTrailDetails as AuditTrailDetailsType } from '../types';
+import type { AuditTrailLabels } from '../utils';
+export interface AuditTrailDetailsProps {
+    documentId: string | null;
+    onFetchDetails: (documentId: string) => Promise<AuditTrailDetailsType>;
+    onClose: () => void;
+    labels?: AuditTrailLabels;
+    translateProperty?: (eventName: string, propertyResource: string) => string;
+    translatePropertyValue?: (eventName: string, propertyResource: string, value: string) => string | null;
+    formatDate?: (date: string) => string;
+}
+export declare function AuditTrailDetails({ documentId, onFetchDetails, onClose, labels, translateProperty, translatePropertyValue, formatDate, }: AuditTrailDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/AuditTrailFilter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AuditTrailFilter
+ * Horizontal filter bar for the audit trail page
+ * Ported from flc-audit-trail-filter (v2) and qex-audit-trail-readable-filter (v1)
+ */
+import type { AuditTrailEvent, AuditTrailQueryParams, AuditTrailSoftware, AuditTrailUserOption, AuditTrailPermissions } from '../types';
+export interface AuditTrailFilterProps {
+    queryParams: AuditTrailQueryParams;
+    events: AuditTrailEvent[];
+    softwares: AuditTrailSoftware[];
+    users?: AuditTrailUserOption[];
+    permissions?: AuditTrailPermissions;
+    isLoading?: boolean;
+    onFilter: (params: AuditTrailQueryParams) => void;
+    onReset?: () => void;
+    onExport?: (format: 'csv' | 'pdf' | 'xlsx') => void;
+    onSoftwareChange?: (softwareId: number) => void;
+}
+export declare function AuditTrailFilter({ queryParams, events, softwares, users, permissions, isLoading, onFilter, onReset, onExport, onSoftwareChange, }: AuditTrailFilterProps): import("react/jsx-runtime").JSX.Element;

package/dist/audit-trail/components/AuditTrailPage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AuditTrailPage
+ * Full audit trail page with grid, filters, and details drawer
+ * Ported from flc-audit-trail-list (v2) and qex-audit-trail-readable-list (v1)
+ */
+import type { AuditTrailCallbacks, AuditTrailPermissions, AuditTrailSoftware } from '../types';
+import type { AuditTrailLabels } from '../utils';
+export interface AuditTrailPageProps {
+    /** Page title */
+    title?: string;
+    /** Software options for filter */
+    softwares: AuditTrailSoftware[];
+    /** Initial software ID */
+    softwareId: number;
+    /** Permissions config */
+    permissions?: AuditTrailPermissions;
+    /** All callbacks for fetching data */
+    callbacks: AuditTrailCallbacks;
+    /** Initial query limit */
+    limit?: number;
+    /** Current user ID (for viewOnlyMyEvents) */
+    currentUserId?: string;
+    /** Custom labels for detail rows */
+    labels?: AuditTrailLabels;
+    /** Format date for display */
+    formatDate?: (date: string) => string;
+    /** Anonymous user label */
+    anonymousLabel?: string;
+}
+export declare function AuditTrailPage({ title, softwares, softwareId: initialSoftwareId, permissions, callbacks, limit, currentUserId, labels, formatDate, anonymousLabel, }: AuditTrailPageProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+export { AuditTrailPage } from './components/AuditTrailPage';
+export type { AuditTrailPageProps } from './components/AuditTrailPage';
+export { AuditTrailFilter } from './components/AuditTrailFilter';
+export type { AuditTrailFilterProps } from './components/AuditTrailFilter';
+export { AuditTrailDetails } from './components/AuditTrailDetails';
+export type { AuditTrailDetailsProps } from './components/AuditTrailDetails';
+export * from './types';
+export { processTrails, buildDetailRows, camelToDash } from './utils';
+export type { AuditTrailLabels } from './utils';

package/dist/audit-trail/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Audit Trail Types
+ * Ported from Angular v1 (qex-audit-trail-readable) and v2 (flc-audit-trail)
+ */
+export interface AuditTrail {
+    documentId: string;
+    eventName: string;
+    entityName: string;
+    entityTypeName: string;
+    software: string;
+    dateTime: string;
+    userEmail: string;
+    userName: string;
+    ip: string;
+    isMobileRequest: boolean;
+    eventId: number;
+    userIdentId: number;
+    translatedSoftware?: string;
+    user?: string;
+    translatedEvent?: string;
+    date?: Date;
+    eventDescription?: string;
+    userPhotoUrl?: string;
+    icon?: string;
+}
+export interface AuditTrailDetails {
+    software: string;
+    dateTime: string;
+    userId: string;
+    userName: string;
+    userEmail: string;
+    associationId: string;
+    isMobileRequest: boolean;
+    commandIsSigned?: boolean;
+    method: string;
+    urlPath: string;
+    eventId: number;
+    eventName: string;
+    commandName: string;
+    ip: string;
+    entities: AuditTrailEntity[];
+}
+export interface AuditTrailEntity {
+    id: string;
+    code: string;
+    name: string;
+    description: string;
+    item: string;
+    date: Date;
+    typeId: number;
+    typeName: string;
+    extra?: AuditTrailExtraProperty[];
+    data: AuditTrailChangedProperty[];
+    association?: AuditTrailAssociation[];
+    isElectronicSigned?: boolean;
+    status?: number;
+    statusName?: string;
+    situation?: number;
+    justification?: string;
+    equipmentType?: string;
+}
+export interface AuditTrailChangedProperty {
+    property: string;
+    propertyCustomName?: string;
+    oldValue: any;
+    newValue: any;
+    children?: AuditTrailChangedProperty[];
+    propertyResource?: string;
+    state: string;
+    tagTranslate?: string;
+    oldValueTagTranslate?: string;
+    details?: any;
+}
+export interface AuditTrailExtraProperty {
+    property: string;
+    value: string;
+    data?: any;
+    translate?: boolean;
+}
+export interface AuditTrailAssociation {
+    id: string;
+    code: string;
+    name: string;
+    status?: number;
+    softwareId?: number;
+    softwareName?: string;
+    type?: number | string;
+    association?: AuditTrailAssociation[];
+}
+export interface AuditTrailEvent {
+    id: number;
+    name: string;
+    translation: string;
+    softwareId: number;
+}
+export interface AuditTrailSoftware {
+    id: number;
+    name: string;
+    software: string;
+    translation: string;
+}
+export interface AuditTrailQueryParams {
+    software: string;
+    softwareId: number;
+    event: string;
+    eventId: number;
+    startDate: Date;
+    endDate: Date;
+    limit: number;
+    softwares: AuditTrailSoftware[];
+    userId?: string;
+    entityId?: string;
+}
+export interface AuditTrailPermissions {
+    viewAllEvents: boolean;
+    viewOnlyMyEvents: boolean;
+    download: boolean;
+}
+export interface AuditTrailUserOption {
+    id: string;
+    name: string;
+    email?: string;
+    avatar?: string;
+}
+export interface AuditTrailDetailRow {
+    name: string;
+    value: string;
+}
+export interface AuditTrailCallbacks {
+    /** Fetch trail list based on query params */
+    onFetchTrails: (params: AuditTrailQueryParams) => Promise<{
+        data: AuditTrail[];
+        totalRows: number;
+    }>;
+    /** Fetch events for a software */
+    onFetchEvents: (softwareId: number) => Promise<AuditTrailEvent[]>;
+    /** Fetch trail details by documentId */
+    onFetchDetails: (documentId: string) => Promise<AuditTrailDetails>;
+    /** Fetch user options for filter */
+    onFetchUsers?: () => Promise<AuditTrailUserOption[]>;
+    /** Export data (csv, pdf, xlsx) */
+    onExport?: (format: 'csv' | 'pdf' | 'xlsx', data: AuditTrail[]) => void;
+    /** Translate event name */
+    translateEvent?: (eventName: string, softwareName: string) => string;
+    /** Translate software name */
+    translateSoftware?: (softwareKey: string) => string;
+    /** Translate detail property */
+    translateProperty?: (eventName: string, propertyResource: string) => string;
+    /** Translate detail property value */
+    translatePropertyValue?: (eventName: string, propertyResource: string, value: string) => string | null;
+}

package/dist/audit-trail/utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Audit Trail Utilities
+ * Ported from Angular v1/v2 detail rendering logic
+ */
+import type { AuditTrail, AuditTrailDetails, AuditTrailDetailRow, AuditTrailEvent, AuditTrailSoftware } from './types';
+/** Process raw trails: translate software/event, compute date, sort desc */
+export declare function processTrails(trails: AuditTrail[], events: AuditTrailEvent[], softwares: AuditTrailSoftware[], anonymousLabel?: string): AuditTrail[];
+export declare function translateEvent(eventName: string, events: AuditTrailEvent[]): string;
+export declare function translateSoftware(software: string, softwares: AuditTrailSoftware[]): string;
+/** Build detail rows from AuditTrailDetails (ported from v1/v2 addHeaderRow, addChangesRow, addFooterRow) */
+export declare function buildDetailRows(details: AuditTrailDetails, options?: {
+    translateProperty?: (eventName: string, propertyResource: string) => string;
+    translatePropertyValue?: (eventName: string, propertyResource: string, value: string) => string | null;
+    formatDate?: (date: string) => string;
+    labels?: Partial<typeof DEFAULT_LABELS>;
+}): AuditTrailDetailRow[];
+export declare function camelToDash(str: string): string;
+declare const DEFAULT_LABELS: {
+    readonly event: "Evento";
+    readonly entityName: "Item";
+    readonly description: "Descrição";
+    readonly justification: "Justificativa";
+    readonly status: "Status";
+    readonly type: "Tipo";
+    readonly references: "Referências";
+    readonly security: "Segurança";
+    readonly electronicSigned: "Assinatura Eletrônica";
+    readonly accomplishedBy: "Realizado por";
+    readonly accomplishedIn: "Realizado em";
+    readonly changedFrom: "de";
+    readonly changedTo: "para";
+    readonly uninformed: "Não informado";
+    readonly stateAdded: "(adicionado)";
+    readonly stateModified: "(modificado)";
+    readonly stateRemoved: "(removido)";
+};
+export type AuditTrailLabels = Partial<typeof DEFAULT_LABELS>;
+export {};

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

@@ -0,0 +1,50 @@
+import { type Dashboard, DashboardFormTab, DashboardShareType, DashboardUpdateTime, DashboardViewType, DashboardPageTime } from './types';
+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[];
+}
+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;
+}
+export declare function DashboardForm({ dashboard, initialTab, isSaving, isQualitfy, users, groups, places, collaborators, onSave, onCancel, className, }: DashboardFormProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,109 @@
+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';
+export type DashboardViewState = {
+    mode: 'list';
+} | {
+    mode: 'view';
+    dashboardId: string;
+} | {
+    mode: 'create';
+} | {
+    mode: 'edit';
+    dashboardId: string;
+} | {
+    mode: 'share';
+    dashboardId: string;
+};
+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;
+}
+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/components/dashboards/dashboard-grid.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from 'react';
+import { DashboardPanelType } from './types';
+export interface GridPanelLayout {
+    id: string;
+    col: number;
+    row: number;
+    sizeX: number;
+    sizeY: number;
+    minSizeX?: number;
+    minSizeY?: number;
+}
+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;
+}
+export declare function getDefaultPanelSize(panelType: DashboardPanelType): {
+    x: number;
+    y: number;
+};
+export declare function getMinPanelSize(panelType: DashboardPanelType): {
+    x: number;
+    y: number;
+};
+export declare function DashboardGrid({ panels, columns, cellHeight, cellGap, allowDragging, showGridLines, renderPanel, onLayoutChange, className, }: DashboardGridProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+import { type Dashboard, type DashboardLimit, QuickFilterDashboard, DashboardLanguage } from './types';
+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;
+}
+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/components/dashboards/dashboard-panel-renderer.d.ts

@@ -0,0 +1,21 @@
+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';
+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;
+}
+export declare function DashboardPanelRenderer({ config, state, data, numericValue, listColumns, cartesianData, cartesianSeries, burndownData, performanceData, matrixRule, matrixRisks, onPanelClick, }: DashboardPanelRendererProps): ReactNode;