import * as _angular_core from '@angular/core';
import { InjectionToken } from '@angular/core';
import * as i1 from '@acorex/platform/domain';
import * as i4 from '@acorex/platform/workflow';
import * as _acorex_platform_layout_builder from '@acorex/platform/layout/builder';
import { AXPDynamicFormDefinition } from '@acorex/platform/layout/builder';
import * as _acorex_platform_layout_widget_core from '@acorex/platform/layout/widget-core';
import { AXPWidgetNode, AXPWidgetColumnNode, AXPPageStatus } from '@acorex/platform/layout/widget-core';
import * as _acorex_modules_report_management from '@acorex/modules/report-management';
import * as _ngrx_signals from '@ngrx/signals';
import * as _acorex_platform_themes_shared from '@acorex/platform/themes/shared';
import * as _acorex_platform_core from '@acorex/platform/core';
import { AXPContextData, AXPGridLayoutOptions, AXPBreadcrumbItem, AXPBackButton, AXPExecuteCommand, AXPActionMenuItem, AXPSystemActionType, AXPExportOptions } from '@acorex/platform/core';
import { AXPPageLayoutBaseComponent } from '@acorex/platform/layout/views';
import { AXPQuerySort } from '@acorex/platform/common';
import { AXPCommand, AXPCommandService } from '@acorex/platform/runtime';
import { AXBarChartValue, AXBarChartOption } from '@acorex/charts/bar-chart';
import { AXChartLegendOptions } from '@acorex/charts/chart-legend';
import * as _acorex_components_button from '@acorex/components/button';
import { AXRowCommandItemClickEvent, AXDataTableRowDbClick, AXRowCommandItem } from '@acorex/components/data-table';
import { AXDataSource } from '@acorex/cdk/common';
import { AXDonutChartValue } from '@acorex/charts/donut-chart';
import { AXLineChartValue } from '@acorex/charts/line-chart';

declare const RootConfig: {
    config: {
        i18n: string;
        module: string;
    };
    module: {
        route: string;
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        dataSet: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        category: {
            name: string;
            fullName: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        report: {
            name: string;
            fullName: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
    };
};

declare class AXMDataSetEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDataSetEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDataSetEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDataSetEntityModule>;
}

declare class AXMReportDefinitionEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMReportDefinitionEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMReportDefinitionEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMReportDefinitionEntityModule>;
}

declare class AXMReportManagementModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMReportManagementModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMReportManagementModule, never, [typeof i1.AXPDomainModule, typeof AXMDataSetEntityModule, typeof AXMReportDefinitionEntityModule, typeof i4.AXPWorkflowModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMReportManagementModule>;
}

declare class AXPReportViewerPageComponent extends AXPPageLayoutBaseComponent {
    protected layoutService: {
        currentMode: _angular_core.Signal<_acorex_platform_themes_shared.AXPThemeMode>;
        currentPalette: _angular_core.Signal<string>;
        systemThemeMode: _angular_core.Signal<_acorex_platform_themes_shared.AXPThemeMode>;
        font: _ngrx_signals.DeepSignal<{
            family: string;
            size: string;
        }>;
        screenSize: _angular_core.Signal<_acorex_platform_themes_shared.AXPScreenSize>;
        deviceType: _angular_core.Signal<_acorex_platform_themes_shared.AXPDeviceType>;
        isTouchDevice: _angular_core.Signal<boolean>;
        overlayLoading: _angular_core.Signal<boolean>;
        navigationLoading: _angular_core.Signal<boolean>;
        overlayLoadingTaskCount: _angular_core.Signal<number>;
        navigationLoadingTaskCount: _angular_core.Signal<number>;
        sideMenuState: _angular_core.Signal<_acorex_platform_themes_shared.AXPSideMenuState>;
        sideMenuWidth: _angular_core.Signal<number>;
        menuOrientation: _angular_core.Signal<_acorex_platform_themes_shared.AXPMenuOrientation>;
        isPrinting: _angular_core.Signal<boolean>;
        isDarkMode: _angular_core.Signal<boolean>;
        isLightMode: _angular_core.Signal<boolean>;
        isSystemMode: _angular_core.Signal<boolean>;
        isSideMenuOpen: _angular_core.Signal<boolean>;
        isSideMenuOverlay: _angular_core.Signal<boolean>;
        isSmall: _angular_core.Signal<boolean>;
        isMedium: _angular_core.Signal<boolean>;
        isLarge: _angular_core.Signal<boolean>;
        isMobileDevice: _angular_core.Signal<boolean>;
        isTabletDevice: _angular_core.Signal<boolean>;
        isDesktopDevice: _angular_core.Signal<boolean>;
        isTouchScreen: _angular_core.Signal<boolean>;
        isOverlayLoading: _angular_core.Signal<boolean>;
        isNavigationLoading: _angular_core.Signal<boolean>;
        isMenuHorizontal: _angular_core.Signal<boolean>;
        changeThemeMode: (theme: _acorex_platform_themes_shared.AXPThemeMode) => void;
        openSideMenu: () => void;
        closeSideMenu: () => void;
        setSideMenuWidth: (width: number) => void;
        toggleSideMenu: () => void;
        setNavigationLoading: (value: boolean, delay?: number) => void;
        setOverlayLoading: (value: boolean, delay?: number) => void;
        loadSettings: () => Promise<void>;
    } & _ngrx_signals.StateSource<{
        currentMode: _acorex_platform_themes_shared.AXPThemeMode;
        currentPalette: string;
        systemThemeMode: _acorex_platform_themes_shared.AXPThemeMode;
        font: {
            family: string;
            size: string;
        };
        screenSize: _acorex_platform_themes_shared.AXPScreenSize;
        deviceType: _acorex_platform_themes_shared.AXPDeviceType;
        isTouchDevice: boolean;
        overlayLoading: boolean;
        navigationLoading: boolean;
        overlayLoadingTaskCount: number;
        navigationLoadingTaskCount: number;
        sideMenuState: _acorex_platform_themes_shared.AXPSideMenuState;
        sideMenuWidth: number;
        menuOrientation: _acorex_platform_themes_shared.AXPMenuOrientation;
        isPrinting: boolean;
    }>;
    private readonly route;
    private readonly router;
    private unsubscriber;
    reportId: _angular_core.InputSignal<string | undefined>;
    reportParameters: _angular_core.InputSignal<Record<string, any>>;
    private filtersForm;
    protected readonly vm: {
        reportDefinition: _angular_core.Signal<_acorex_modules_report_management.AXPReportDefinition | null>;
        currentLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        filterContext: _angular_core.Signal<AXPContextData>;
        categoriesPath: _angular_core.Signal<any[]>;
        allowFetchData: _angular_core.Signal<boolean>;
        shouldExecuteReport: _angular_core.Signal<boolean>;
        lastAppliedFilterContext: _angular_core.Signal<AXPContextData | null>;
        hasBeenExecuted: _angular_core.Signal<boolean>;
        status: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPPageStatus>;
        error: _angular_core.Signal<string | null>;
        availableLayouts: _angular_core.Signal<_acorex_modules_report_management.AXPLayoutSwitcherOption[]>;
        defaultLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        activeLayoutId: _angular_core.Signal<string | null>;
        layoutType: _angular_core.Signal<"table" | "chart" | null>;
        tableLayoutConfig: _angular_core.Signal<_acorex_modules_report_management.AXPReportTableLayout | null>;
        chartLayoutConfig: _angular_core.Signal<_acorex_modules_report_management.AXPReportChartLayout | null>;
        isLoading: _angular_core.Signal<boolean>;
        isExecuting: _angular_core.Signal<boolean>;
        hasError: _angular_core.Signal<boolean>;
        canExecute: _angular_core.Signal<boolean>;
        hasMultipleLayouts: _angular_core.Signal<boolean>;
        title: _angular_core.Signal<string>;
        description: _angular_core.Signal<string | null>;
        formDefinition: _angular_core.Signal<_acorex_platform_layout_builder.AXPDynamicFormDefinition>;
        isTableLayout: _angular_core.Signal<boolean>;
        isChartLayout: _angular_core.Signal<boolean>;
        hasUnappliedFilters: _angular_core.Signal<boolean>;
        canSwitchLayout: _angular_core.Signal<boolean>;
        canSelectRows: _angular_core.Signal<boolean | undefined>;
        loadReport: (reportId: string) => Promise<void>;
        switchLayout: (layoutId: string) => void;
        executeReport: () => Promise<void>;
        fetchData: (parameters?: AXPContextData) => Promise<_acorex_modules_report_management.AXPExecutionReportCommandResult | null>;
        updateFilterContext: (context: Record<string, any>) => void;
        clearFilters: () => void;
        resetFilters: () => void;
        exportReport: (format: string) => Promise<void>;
        refresh: () => Promise<void>;
        clearError: () => void;
        clearExecutionState: () => void;
        reset: () => void;
    } & _ngrx_signals.StateSource<{
        reportDefinition: _acorex_modules_report_management.AXPReportDefinition | null;
        currentLayout: _acorex_modules_report_management.AXPReportLayoutDefinition | null;
        filterContext: AXPContextData;
        categoriesPath: any[];
        allowFetchData: boolean;
        shouldExecuteReport: boolean;
        lastAppliedFilterContext: AXPContextData | null;
        hasBeenExecuted: boolean;
        status: _acorex_platform_layout_widget_core.AXPPageStatus;
        error: string | null;
    }>;
    protected showFiltersPanel: () => boolean;
    protected showReportDisplay: () => boolean;
    private baseRoutes;
    protected defaultLayout: () => AXPGridLayoutOptions;
    protected compactLayout: () => AXPGridLayoutOptions;
    ngOnInit(): Promise<void>;
    /**
     * Effect to handle data fetching when chart configuration changes
     */
    private loadReportAndRefresh;
    /**
     * Synchronizes filter context to URL query parameters
     * @param filterContext The current filter context to sync
     */
    private syncFiltersToUrl;
    protected handleFiltersChange(event: AXPContextData): void;
    protected handleFiltersInitiated(event: AXPContextData): void;
    protected handleExecuteReport(): Promise<void>;
    protected handleRefresh(): void;
    protected handleClearFilters(): void;
    protected getPageBreadcrumbs(): Promise<AXPBreadcrumbItem[]>;
    getPageTitle(): Promise<string>;
    getPageDescription(): Promise<string | null>;
    getBackButton(): Promise<AXPBackButton | null>;
    onBackButtonClick(): Promise<void>;
    execute(command: AXPExecuteCommand): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPReportViewerPageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPReportViewerPageComponent, "axp-report-viewer-page", never, { "reportId": { "alias": "reportId"; "required": false; "isSignal": true; }; "reportParameters": { "alias": "reportParameters"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type AXPReportLayoutType = 'table' | 'chart' | 'cards' | 'custom';
interface AXPReportCategory {
    id: string;
    title: string;
    description?: string;
    parentId?: string;
    hasChild?: boolean;
    hasReport?: boolean;
}
interface AXPReportDefinition {
    id: string;
    title: string;
    description?: string;
    categoryIds: string[];
    parameterGroups: AXPReportParameterGroup[];
    permissions?: string[];
    layouts: AXPReportLayoutDefinition[];
    defaultLayoutId: string;
}
/**
 * Layout Definition - Associates a layout with metadata
 */
interface AXPReportLayoutDefinition {
    id: string;
    title: string;
    description?: string;
    icon?: string;
    layout: AXPReportLayout;
    dataSource?: AXPReportDataSource;
    isDefault?: boolean;
    export?: AXPExportOptions;
}
interface AXPReportParameterGroup {
    name: string;
    title: string;
    description?: string;
    parameters: AXPReportParameter[];
}
interface AXPReportParameter {
    path: string;
    title: string;
    description?: string;
    widget: AXPWidgetNode;
}
type AXPReportDataSource = AXPQueryDataSource | AXPCustomDataSource | AXPAggregatedDataSource | AXPTransformedDataSource;
/**
 * Query Data Source - Used for executing predefined queries (AXPQuery)
 */
interface AXPQueryDataSource {
    type: 'query';
    name: string;
    description?: string;
    inputs?: AXPReportParameterBinding[];
    sortFields?: AXPQuerySort[];
    pagination?: boolean;
}
/**
 * Custom Data Source - Used for fetching data from custom providers like REST APIs or external services
 */
interface AXPCustomDataSource {
    type: 'custom';
    provider: string;
    description?: string;
    inputs?: AXPReportParameterBinding[];
    options?: {
        [key: string]: any;
    };
}
/**
 * Parameter Binding - Maps report-level parameters to actual query/command input structure
 */
interface AXPReportParameterBinding {
    parameterKey: string;
    bindTo: string;
}
/**
 * Aggregated Data Source - Used for pre-aggregated data optimized for charts
 */
interface AXPAggregatedDataSource {
    type: 'aggregated';
    baseQuery: string;
    description?: string;
    groupBy: string[];
    aggregations: AXPAggregation[];
    inputs?: AXPReportParameterBinding[];
}
/**
 * Transformed Data Source - Applies transformations to existing data sources
 */
interface AXPTransformedDataSource {
    type: 'transformed';
    baseDataSource: AXPReportDataSource;
    description?: string;
    transformations: AXPDataTransformation[];
    inputs?: AXPReportParameterBinding[];
}
/**
 * Aggregation operation for aggregated data sources
 */
interface AXPAggregation {
    field: string;
    operation: 'sum' | 'avg' | 'count' | 'min' | 'max' | 'distinct';
    alias?: string;
}
/**
 * Data transformation operation
 */
interface AXPDataTransformation {
    type: 'filter' | 'sort' | 'group' | 'pivot' | 'format';
    config: Record<string, any>;
}
type AXPReportLayout = AXPReportTableLayout | AXPReportChartLayout;
/**
 * Table Layout - Displays data in tabular format
 */
interface AXPReportTableLayoutRowAction extends AXPActionMenuItem {
    priority: 'primary' | 'secondary';
    type: AXPSystemActionType | string;
    default?: boolean;
}
interface AXPReportTableLayout {
    type: 'table';
    columns: AXPReportColumn[];
    actions?: AXPReportTableLayoutRowAction[];
    options?: AXPTableOptions;
    groupBy?: string[];
    conditionalFormatting?: AXPConditionalFormatRule[];
    summary?: AXPReportSummaryOptions[];
    header?: AXPReportHeaderFooter;
    footer?: AXPReportHeaderFooter;
}
interface AXPTableOptions {
    pagination?: boolean;
    stickyHeader?: boolean;
    stripedRows?: boolean;
    sorting?: AXPQuerySort[];
    selectable?: {
        mode: 'single' | 'multiple' | 'none';
    };
}
/**
 * Chart Layout - Displays data in various chart formats
 */
interface AXPReportChartLayout {
    type: 'chart';
    options: AXPReportChartOptions;
    header?: AXPReportHeaderFooter;
    footer?: AXPReportHeaderFooter;
}
interface AXPReportChartOptions {
    chartType: 'bar' | 'line' | 'pie' | 'doughnut' | 'area' | 'scatter' | 'radar' | 'mixed';
    dataMapping: AXPChartDataMapping;
    styling?: AXPChartStyling;
    interactivity?: AXPChartInteractivity;
}
/**
 * Chart Data Mapping Configuration
 */
interface AXPChartDataMapping {
    xField: string;
    yFields: string | string[];
    groupBy?: string;
    seriesField?: string;
    sizeField?: string;
    colorField?: string;
    labelField?: string;
    aggregation?: {
        method: 'sum' | 'avg' | 'count' | 'min' | 'max';
        field: string;
    };
}
/**
 * Chart Visual Styling Configuration
 */
interface AXPChartStyling {
    colorScheme?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'custom';
    customColors?: string[];
    gridLines?: boolean;
    legend?: {
        show: boolean;
        position: 'top' | 'bottom' | 'left' | 'right';
    };
    xAxis?: AXPChartAxisConfig;
    yAxis?: AXPChartAxisConfig;
    animation?: {
        enabled: boolean;
        duration?: number;
    };
    chartSpecific?: {
        bar?: {
            orientation: 'vertical' | 'horizontal';
            mode: 'grouped' | 'stacked';
            barWidth?: number;
        };
        line?: {
            style: 'straight' | 'curved' | 'stepped';
            showPoints?: boolean;
            tension?: number;
        };
        area?: {
            mode: 'normal' | 'stacked' | 'percentage';
            opacity?: number;
        };
        pie?: {
            startAngle?: number;
            innerRadius?: number;
            showLabels?: boolean;
        };
    };
}
/**
 * Chart Axis Configuration
 */
interface AXPChartAxisConfig {
    title?: string;
    show?: boolean;
    type?: 'linear' | 'logarithmic' | 'datetime' | 'category';
    min?: number | string;
    max?: number | string;
    format?: string;
    gridLines?: boolean;
    tickInterval?: number;
}
/**
 * Chart Interactivity Configuration
 */
interface AXPChartInteractivity {
    zoom?: {
        enabled: boolean;
        mode?: 'x' | 'y' | 'xy';
    };
    tooltips?: {
        enabled: boolean;
        format?: string;
        showOnHover?: boolean;
    };
    onClick?: {
        enabled: boolean;
        action?: 'drill-down' | 'filter' | 'custom';
    };
    selection?: {
        enabled: boolean;
        mode?: 'single' | 'multiple';
    };
    export?: {
        enabled: boolean;
        formats?: ('png' | 'jpg' | 'pdf' | 'svg')[];
    };
}
interface AXPReportColumn {
    field: string;
    title?: string;
    visible?: boolean;
    width?: number;
    align?: 'left' | 'center' | 'right';
    widget?: AXPWidgetColumnNode;
}
interface AXPReportSummaryOptions {
    field: string;
    operation: 'sum' | 'avg' | 'count' | 'min' | 'max';
    displayIn: 'groupFooter' | 'reportFooter';
}
interface AXPConditionalFormatRule {
    field: string;
    condition: '>' | '<' | '=' | '!=' | 'contains';
    value: any;
    style: {
        color?: string;
        backgroundColor?: string;
        fontWeight?: 'normal' | 'bold';
    };
}
interface AXPReportHeaderFooter {
    title?: string;
    logoUrl?: string;
    showDate?: boolean;
    showParameters?: boolean;
    customHtml?: string;
}
/**
 * Layout switcher options for UI components
 */
interface AXPLayoutSwitcherOption {
    id: string;
    title: string;
    icon?: string;
    type: AXPReportLayoutType;
}
/**
 * Runtime layout selection state
 */
interface AXPReportLayoutState {
    reportId: string;
    activeLayoutId: string;
    availableLayouts: AXPLayoutSwitcherOption[];
}
/**
 * Layout validation result
 */
interface AXPLayoutValidationResult {
    isValid: boolean;
    errors: string[];
    layoutId: string;
}
/**
 * Data source resolution result for a specific layout
 */
interface AXPLayoutDataSourceResolution {
    layoutId: string;
    dataSource: AXPReportDataSource;
    source: 'layout' | 'report' | 'none';
}
/**
 * Layout execution context with resolved data source
 */
interface AXPLayoutExecutionContext {
    reportId: string;
    layoutId: string;
    dataSource: AXPReportDataSource;
    parameters: Record<string, any>;
}
type AXPExecutionReportResult = {
    type: 'table';
    items: Record<string, unknown>[];
    total: number;
} | {
    type: 'chart';
    data: Record<string, unknown>;
} | {
    type: 'cards';
    items: Record<string, unknown>[];
} | {
    type: 'custom';
    data: unknown;
};
type AXPExecutionReportCommandResult = AXPReportLayout & {
    data: AXPExecutionReportResult;
};
interface AXPExecutionReportCommand extends AXPCommand<AXPLayoutExecutionContext, AXPExecutionReportCommandResult> {
}
/**
 * Report execution status and metadata
 */
interface AXPReportExecutionStatus {
    reportId: string;
    layoutId: string;
    status: 'pending' | 'executing' | 'completed' | 'failed' | 'cancelled';
    startTime: Date;
    endTime?: Date;
    duration?: number;
    recordCount?: number;
    error?: AXPReportExecutionError;
}
/**
 * Detailed error information for report execution
 */
interface AXPReportExecutionError {
    code: string;
    message: string;
    details?: Record<string, unknown>;
    stack?: string;
}
/**
 * Report execution request with options
 */
interface AXPReportExecutionRequest {
    reportId: string;
    layoutId: string;
    parameters: Record<string, unknown>;
    options?: AXPReportExecutionOptions;
}
/**
 * Options for report execution
 */
interface AXPReportExecutionOptions {
    timeout?: number;
    priority?: 'low' | 'normal' | 'high';
    cache?: boolean;
    cacheTimeout?: number;
}

type AXPReportDefinitionProviderToken = AXPReportDefinitionProvider | Promise<AXPReportDefinitionProvider>;
declare const AXP_REPORT_DEFINITION_PROVIDER: InjectionToken<AXPReportDefinitionProviderToken[]>;
interface AXPReportDefinitionProvider {
    getList(categoryId: string): Promise<AXPReportDefinition[]>;
    getById(id: string): Promise<AXPReportDefinition | undefined>;
}
type AXPReportCategoryProviderToken = AXPReportCategoryProvider | Promise<AXPReportCategoryProvider>;
declare const AXP_REPORT_CATEGORY_PROVIDER: InjectionToken<AXPReportCategoryProviderToken[]>;
interface AXPReportCategoryProvider {
    getList(parentId?: string): Promise<AXPReportCategory[]>;
    getById(id: string): Promise<AXPReportCategory | undefined>;
}

declare class AXPReportDefinitionService {
    private readonly categoryProviders;
    private readonly definitionProviders;
    /** Cache for definitions by categoryId. */
    private definitionsByCategory;
    /** Cache for categories by id. */
    private categoriesById;
    /** Cache for categories by parentId. */
    private categoriesByParentId;
    /**
     * Returns all categories for a given parentId, loading from providers if not cached.
     * Continues reading from other providers even if one fails.
     */
    getCategories(parentId?: string): Promise<AXPReportCategory[]>;
    /**
     * Returns all report definitions for a given categoryId, loading from providers if not cached.
     * Continues reading from other providers even if one fails.
     */
    getReportsByCategoryId(categoryId: string): Promise<AXPReportDefinition[]>;
    /**
     * Returns a report definition by its id. Continues through providers on errors.
     */
    getReportById(id: string): Promise<AXPReportDefinition | undefined>;
    /**
     * Returns a category by its id, using cache and providers if needed.
     */
    getCategoryById(categoryId: string): Promise<AXPReportCategory | undefined>;
    /**
     * Returns the full categories path from root to the specified category.
     */
    getCategoriesPathById(categoryId: string): Promise<AXPReportCategory[]>;
    /**
     * Returns the full categories path for the category that contains the specified report.
     */
    getCategoriesPathByReportId(reportId: string): Promise<AXPReportCategory[]>;
    /**
     * Returns the category ID that contains a specific report.
     */
    getCategoryIdByReportId(reportId: string): Promise<string | undefined>;
    clearDefinitionsCache(): void;
    clearCategoriesCache(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPReportDefinitionService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPReportDefinitionService>;
}

declare function AXPieChartReportMapper(data: Record<string, number>): AXDonutChartValue;
declare function AXBarChartReportMapper(data: Record<string, number>): AXBarChartValue;
declare function AXLineChartReportMapper(data: Record<string, number>): AXLineChartValue;

declare const AXPReportViewerViewModel: _angular_core.Type<{
    reportDefinition: _angular_core.Signal<AXPReportDefinition | null>;
    currentLayout: _angular_core.Signal<AXPReportLayoutDefinition | null>;
    filterContext: _angular_core.Signal<AXPContextData>;
    categoriesPath: _angular_core.Signal<any[]>;
    allowFetchData: _angular_core.Signal<boolean>;
    shouldExecuteReport: _angular_core.Signal<boolean>;
    lastAppliedFilterContext: _angular_core.Signal<AXPContextData | null>;
    hasBeenExecuted: _angular_core.Signal<boolean>;
    status: _angular_core.Signal<AXPPageStatus>;
    error: _angular_core.Signal<string | null>;
    availableLayouts: _angular_core.Signal<AXPLayoutSwitcherOption[]>;
    defaultLayout: _angular_core.Signal<AXPReportLayoutDefinition | null>;
    activeLayoutId: _angular_core.Signal<string | null>;
    layoutType: _angular_core.Signal<"table" | "chart" | null>;
    tableLayoutConfig: _angular_core.Signal<AXPReportTableLayout | null>;
    chartLayoutConfig: _angular_core.Signal<AXPReportChartLayout | null>;
    isLoading: _angular_core.Signal<boolean>;
    isExecuting: _angular_core.Signal<boolean>;
    hasError: _angular_core.Signal<boolean>;
    canExecute: _angular_core.Signal<boolean>;
    hasMultipleLayouts: _angular_core.Signal<boolean>;
    title: _angular_core.Signal<string>;
    description: _angular_core.Signal<string | null>;
    formDefinition: _angular_core.Signal<AXPDynamicFormDefinition>;
    isTableLayout: _angular_core.Signal<boolean>;
    isChartLayout: _angular_core.Signal<boolean>;
    hasUnappliedFilters: _angular_core.Signal<boolean>;
    canSwitchLayout: _angular_core.Signal<boolean>;
    canSelectRows: _angular_core.Signal<boolean | undefined>;
    loadReport: (reportId: string) => Promise<void>;
    switchLayout: (layoutId: string) => void;
    executeReport: () => Promise<void>;
    fetchData: (parameters?: AXPContextData) => Promise<AXPExecutionReportCommandResult | null>;
    updateFilterContext: (context: Record<string, any>) => void;
    clearFilters: () => void;
    resetFilters: () => void;
    exportReport: (format: string) => Promise<void>;
    refresh: () => Promise<void>;
    clearError: () => void;
    clearExecutionState: () => void;
    reset: () => void;
} & _ngrx_signals.StateSource<{
    reportDefinition: AXPReportDefinition | null;
    currentLayout: AXPReportLayoutDefinition | null;
    filterContext: AXPContextData;
    categoriesPath: any[];
    allowFetchData: boolean;
    shouldExecuteReport: boolean;
    lastAppliedFilterContext: AXPContextData | null;
    hasBeenExecuted: boolean;
    status: AXPPageStatus;
    error: string | null;
}>>;

declare class AXPReportBarChartViewComponent {
    #private;
    protected readonly vm: {
        reportDefinition: _angular_core.Signal<_acorex_modules_report_management.AXPReportDefinition | null>;
        currentLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        filterContext: _angular_core.Signal<_acorex_platform_core.AXPContextData>;
        categoriesPath: _angular_core.Signal<any[]>;
        allowFetchData: _angular_core.Signal<boolean>;
        shouldExecuteReport: _angular_core.Signal<boolean>;
        lastAppliedFilterContext: _angular_core.Signal<_acorex_platform_core.AXPContextData | null>;
        hasBeenExecuted: _angular_core.Signal<boolean>;
        status: _angular_core.Signal<AXPPageStatus>;
        error: _angular_core.Signal<string | null>;
        availableLayouts: _angular_core.Signal<_acorex_modules_report_management.AXPLayoutSwitcherOption[]>;
        defaultLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        activeLayoutId: _angular_core.Signal<string | null>;
        layoutType: _angular_core.Signal<"table" | "chart" | null>;
        tableLayoutConfig: _angular_core.Signal<_acorex_modules_report_management.AXPReportTableLayout | null>;
        chartLayoutConfig: _angular_core.Signal<AXPReportChartLayout | null>;
        isLoading: _angular_core.Signal<boolean>;
        isExecuting: _angular_core.Signal<boolean>;
        hasError: _angular_core.Signal<boolean>;
        canExecute: _angular_core.Signal<boolean>;
        hasMultipleLayouts: _angular_core.Signal<boolean>;
        title: _angular_core.Signal<string>;
        description: _angular_core.Signal<string | null>;
        formDefinition: _angular_core.Signal<_acorex_platform_layout_builder.AXPDynamicFormDefinition>;
        isTableLayout: _angular_core.Signal<boolean>;
        isChartLayout: _angular_core.Signal<boolean>;
        hasUnappliedFilters: _angular_core.Signal<boolean>;
        canSwitchLayout: _angular_core.Signal<boolean>;
        canSelectRows: _angular_core.Signal<boolean | undefined>;
        loadReport: (reportId: string) => Promise<void>;
        switchLayout: (layoutId: string) => void;
        executeReport: () => Promise<void>;
        fetchData: (parameters?: _acorex_platform_core.AXPContextData) => Promise<_acorex_modules_report_management.AXPExecutionReportCommandResult | null>;
        updateFilterContext: (context: Record<string, any>) => void;
        clearFilters: () => void;
        resetFilters: () => void;
        exportReport: (format: string) => Promise<void>;
        refresh: () => Promise<void>;
        clearError: () => void;
        clearExecutionState: () => void;
        reset: () => void;
    } & _ngrx_signals.StateSource<{
        reportDefinition: _acorex_modules_report_management.AXPReportDefinition | null;
        currentLayout: _acorex_modules_report_management.AXPReportLayoutDefinition | null;
        filterContext: _acorex_platform_core.AXPContextData;
        categoriesPath: any[];
        allowFetchData: boolean;
        shouldExecuteReport: boolean;
        lastAppliedFilterContext: _acorex_platform_core.AXPContextData | null;
        hasBeenExecuted: boolean;
        status: AXPPageStatus;
        error: string | null;
    }>;
    protected readonly AXPPageStatus: typeof AXPPageStatus;
    /**
     * Current chart layout configuration
     */
    protected readonly chartLayout: _angular_core.Signal<AXPReportChartLayout | null>;
    /**
     * Chart configuration options
     */
    protected readonly chartOptions: _angular_core.Signal<_acorex_modules_report_management.AXPReportChartOptions | null>;
    /**
     * Chart type for rendering
     */
    protected readonly chartType: _angular_core.Signal<"bar" | "line" | "pie" | "doughnut" | "area" | "scatter" | "radar" | "mixed">;
    /**
     * Data mapping configuration
     */
    protected readonly dataMapping: _angular_core.Signal<_acorex_modules_report_management.AXPChartDataMapping | null>;
    /**
     * Handle chart click events
     */
    protected handleChartClick(event: any): void;
    /**
     * Handle chart data point selection
     */
    protected handleDataPointSelect(event: any): void;
    /**
     * Check if chart is ready to render
     */
    protected isChartReady(): boolean;
    /**
     * Get chart configuration for rendering
     */
    protected getChartConfig(): any;
    protected barChartData: _angular_core.WritableSignal<AXBarChartValue>;
    protected barChartOptions: _angular_core.WritableSignal<AXBarChartOption>;
    protected legendOptions: _angular_core.WritableSignal<AXChartLegendOptions>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPReportBarChartViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPReportBarChartViewComponent, "axp-report-bar-chart-view", never, {}, {}, never, never, true, never>;
}

declare class AXPReportTableViewComponent {
    #private;
    protected readonly vm: {
        reportDefinition: _angular_core.Signal<_acorex_modules_report_management.AXPReportDefinition | null>;
        currentLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        filterContext: _angular_core.Signal<_acorex_platform_core.AXPContextData>;
        categoriesPath: _angular_core.Signal<any[]>;
        allowFetchData: _angular_core.Signal<boolean>;
        shouldExecuteReport: _angular_core.Signal<boolean>;
        lastAppliedFilterContext: _angular_core.Signal<_acorex_platform_core.AXPContextData | null>;
        hasBeenExecuted: _angular_core.Signal<boolean>;
        status: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPPageStatus>;
        error: _angular_core.Signal<string | null>;
        availableLayouts: _angular_core.Signal<_acorex_modules_report_management.AXPLayoutSwitcherOption[]>;
        defaultLayout: _angular_core.Signal<_acorex_modules_report_management.AXPReportLayoutDefinition | null>;
        activeLayoutId: _angular_core.Signal<string | null>;
        layoutType: _angular_core.Signal<"table" | "chart" | null>;
        tableLayoutConfig: _angular_core.Signal<AXPReportTableLayout | null>;
        chartLayoutConfig: _angular_core.Signal<_acorex_modules_report_management.AXPReportChartLayout | null>;
        isLoading: _angular_core.Signal<boolean>;
        isExecuting: _angular_core.Signal<boolean>;
        hasError: _angular_core.Signal<boolean>;
        canExecute: _angular_core.Signal<boolean>;
        hasMultipleLayouts: _angular_core.Signal<boolean>;
        title: _angular_core.Signal<string>;
        description: _angular_core.Signal<string | null>;
        formDefinition: _angular_core.Signal<_acorex_platform_layout_builder.AXPDynamicFormDefinition>;
        isTableLayout: _angular_core.Signal<boolean>;
        isChartLayout: _angular_core.Signal<boolean>;
        hasUnappliedFilters: _angular_core.Signal<boolean>;
        canSwitchLayout: _angular_core.Signal<boolean>;
        canSelectRows: _angular_core.Signal<boolean | undefined>;
        loadReport: (reportId: string) => Promise<void>;
        switchLayout: (layoutId: string) => void;
        executeReport: () => Promise<void>;
        fetchData: (parameters?: _acorex_platform_core.AXPContextData) => Promise<_acorex_modules_report_management.AXPExecutionReportCommandResult | null>;
        updateFilterContext: (context: Record<string, any>) => void;
        clearFilters: () => void;
        resetFilters: () => void;
        exportReport: (format: string) => Promise<void>;
        refresh: () => Promise<void>;
        clearError: () => void;
        clearExecutionState: () => void;
        reset: () => void;
    } & _ngrx_signals.StateSource<{
        reportDefinition: _acorex_modules_report_management.AXPReportDefinition | null;
        currentLayout: _acorex_modules_report_management.AXPReportLayoutDefinition | null;
        filterContext: _acorex_platform_core.AXPContextData;
        categoriesPath: any[];
        allowFetchData: boolean;
        shouldExecuteReport: boolean;
        lastAppliedFilterContext: _acorex_platform_core.AXPContextData | null;
        hasBeenExecuted: boolean;
        status: _acorex_platform_layout_widget_core.AXPPageStatus;
        error: string | null;
    }>;
    protected readonly commandService: AXPCommandService;
    private readonly grid;
    protected handleRowClick(event: AXRowCommandItemClickEvent): void;
    protected handleDbRowClick(event: AXDataTableRowDbClick): void;
    protected handleRowAction(name: string, data: any): void;
    protected readonly layout: _angular_core.Signal<AXPReportTableLayout>;
    protected readonly dataSource: AXDataSource<any>;
    protected readonly columns: _angular_core.Signal<{
        field: string;
        title: string;
        width: string | number;
        visible: boolean;
        align: "left" | "right" | "center";
        widget: AXPWidgetColumnNode;
    }[]>;
    protected readonly paginationEnabled: _angular_core.Signal<boolean>;
    protected readonly primaryRowAction: _angular_core.Signal<_acorex_components_button.AXButtonItemListItem[]>;
    protected readonly hasPrimaryRowAction: _angular_core.Signal<boolean>;
    protected readonly secondaryRowAction: _angular_core.Signal<_acorex_components_button.AXButtonItemListItem[]>;
    protected readonly hasSecondaryRowAction: _angular_core.Signal<boolean>;
    protected readonly defaultRowAction: _angular_core.Signal<_acorex_components_button.AXButtonItemListItem | null>;
    protected convertToRowCommandItem(action: AXPReportTableLayoutRowAction): AXRowCommandItem;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPReportTableViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPReportTableViewComponent, "axp-report-table-view", never, {}, {}, never, never, true, never>;
}

export { AXBarChartReportMapper, AXLineChartReportMapper, AXMReportManagementModule, AXPReportBarChartViewComponent, AXPReportDefinitionService, AXPReportTableViewComponent, AXPReportViewerPageComponent, AXPReportViewerViewModel, AXP_REPORT_CATEGORY_PROVIDER, AXP_REPORT_DEFINITION_PROVIDER, AXPieChartReportMapper, RootConfig };
export type { AXPAggregatedDataSource, AXPAggregation, AXPChartAxisConfig, AXPChartDataMapping, AXPChartInteractivity, AXPChartStyling, AXPConditionalFormatRule, AXPCustomDataSource, AXPDataTransformation, AXPExecutionReportCommand, AXPExecutionReportCommandResult, AXPExecutionReportResult, AXPLayoutDataSourceResolution, AXPLayoutExecutionContext, AXPLayoutSwitcherOption, AXPLayoutValidationResult, AXPQueryDataSource, AXPReportCategory, AXPReportCategoryProvider, AXPReportCategoryProviderToken, AXPReportChartLayout, AXPReportChartOptions, AXPReportColumn, AXPReportDataSource, AXPReportDefinition, AXPReportDefinitionProvider, AXPReportDefinitionProviderToken, AXPReportExecutionError, AXPReportExecutionOptions, AXPReportExecutionRequest, AXPReportExecutionStatus, AXPReportHeaderFooter, AXPReportLayout, AXPReportLayoutDefinition, AXPReportLayoutState, AXPReportLayoutType, AXPReportParameter, AXPReportParameterBinding, AXPReportParameterGroup, AXPReportSummaryOptions, AXPReportTableLayout, AXPReportTableLayoutRowAction, AXPTableOptions, AXPTransformedDataSource };
