yw-charts-library 0.0.2

package/index.d.ts

@@ -0,0 +1,741 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, OnInit, AfterViewInit, ElementRef, EnvironmentInjector, ApplicationRef, SimpleChanges, OnChanges, DoCheck, OnDestroy, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { GridStackWidget } from 'gridstack';
+import { LegendSettingsModel, TooltipSettingsModel, AccumulationDataLabelSettingsModel } from '@syncfusion/ej2-angular-charts';
+import { CircularGaugeComponent } from '@syncfusion/ej2-angular-circulargauge';
+import { FormGroup, FormBuilder, FormArray } from '@angular/forms';
+import { NzMessageService } from 'ng-zorro-antd/message';
+
+declare class YwChartsLibraryService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<YwChartsLibraryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<YwChartsLibraryService>;
+}
+
+declare class YwChartsLibraryComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<YwChartsLibraryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<YwChartsLibraryComponent, "lib-yw-charts-library", never, {}, {}, never, never, true, never>;
+}
+
+interface SyncfusionConfig {
+    licenseKey: string;
+}
+declare const SYNCFUSION_CONFIG: InjectionToken<SyncfusionConfig>;
+
+/**
+ * Provee la inicialización de la licencia de Syncfusion.
+ * El consumidor SOLO debe llamar a esta función desde su app.config.ts.
+ */
+declare function provideSyncfusionLicense(config: SyncfusionConfig): EnvironmentProviders;
+
+interface YwWidgetConfigInterface {
+    widgetId: string;
+    title: string;
+    typeComponent: string;
+    showConfigButtons?: boolean;
+    layoutConfig: YwWidgetLayoutInterface;
+    widgetStyle?: YwWidgetStyleInterface;
+    controlConfig: any;
+    controlTables: string[];
+}
+interface YwWidgetLayoutInterface extends GridStackWidget {
+    id: string;
+    autoPosition?: boolean;
+    x?: number;
+    y?: number;
+    w: number;
+    h: number;
+    content: any;
+}
+interface YwWidgetStyleInterface {
+    widgetBackgroundColor?: string;
+    widgetBorderColor?: string;
+}
+declare const DEFAULT_WIDGET_STYLE: YwWidgetStyleInterface;
+
+interface YwDashboardLayoutInterface {
+    margin: number;
+    cellHeight: number;
+    columns: number;
+    float?: boolean;
+    noOverlap?: boolean;
+    resizable?: any;
+    columnOpts?: {
+        breakpointForWindow: boolean;
+        breakpoints: YwGridStackbreakpoints[];
+        layout: any;
+    };
+}
+interface YwGridStackbreakpoints {
+    w: number;
+    c: number;
+}
+interface YwDashboardConfigInterface {
+    showConfigButtons: boolean;
+    lockPositionWidgets: boolean;
+    layoutConfig: YwDashboardLayoutInterface;
+    controlListConfig: YwWidgetConfigInterface[];
+}
+interface YwDashboardDataInterface {
+    tableName: string;
+    tableData: any[];
+}
+interface YwDashboardStyleInterface {
+    canvasBackgroundColor: string;
+    widgetBackgroundColor: string;
+    widgetBorderColor: string;
+}
+declare const YwDashboardWidgetTypes: any[];
+
+declare const YwDashboardWidgetFilterTypes: any[];
+interface YwDashboardFilterConfigInterface {
+    showConfigButtons: boolean;
+    lockPositionWidgets: boolean;
+    controlListConfig: YwDashboardWidgetFilterConfigInterface[];
+}
+interface YwDashboardWidgetFilterConfigInterface {
+    widgetId: string;
+    typeComponent: string;
+    label: string;
+    clearTitleLabel?: string;
+    showConfigButtons?: boolean;
+    controlTable?: string;
+    controlFilterData?: any;
+    configComponent: YwBaseSlicerFilterConfig | YwButtonSlicerFilterConfig | YwListSlicerFilterConfig;
+}
+interface YwWidgetFilterConfigInterface {
+    widgetId: string;
+    typeComponent: string;
+    label: string;
+    clearTitleLabel?: string;
+    showConfigButtons?: boolean;
+    controlTable: string;
+}
+interface YwBaseSlicerFilterConfig {
+    dataType: string;
+    step?: any;
+    min?: any;
+    max?: any;
+    minCurrent?: any;
+    maxCurrent?: any;
+    filterField: string;
+}
+interface YwButtonSlicerFilterConfig {
+    dataType?: string;
+    allowMultiple?: boolean;
+    options: any[];
+    currentIds?: string[] | number[];
+    filterField: string;
+    filterFieldId: string;
+}
+interface YwListSlicerFilterConfig {
+    dataType: string;
+    minDate?: any;
+    maxDate?: any;
+    dateHierarchyType?: 'YEAR_TRIMESTER_MONTH' | 'YEAR_SEMESTER_MONTH' | 'SEMESTER_MONTH_WEEK';
+    rawData?: any;
+    currentSelectedId?: any;
+    filterField: string;
+    filterFieldN2?: string;
+    filterFieldN3?: string;
+}
+
+declare class YwDashboardComponent implements OnInit, AfterViewInit {
+    private environmentInjector;
+    private appRef;
+    gridContainer: ElementRef;
+    private grid;
+    private widgetsActivos;
+    showControls: i0.InputSignal<boolean>;
+    showFilter: i0.InputSignal<boolean>;
+    allIsLocked: i0.WritableSignal<boolean>;
+    drawerfiltervisible: boolean;
+    drawerconfigvisible: boolean;
+    drawerCurrentWidgetObject: any;
+    isLocked: boolean;
+    private countWidget;
+    layoutConfig: YwDashboardLayoutInterface;
+    dashboardStyle: YwDashboardStyleInterface;
+    dashboardConfig: YwDashboardConfigInterface;
+    dashboardData: YwDashboardDataInterface[];
+    dashboardItems: YwWidgetLayoutInterface[];
+    dashboardFilterConfig: YwDashboardFilterConfigInterface;
+    constructor(environmentInjector: EnvironmentInjector, appRef: ApplicationRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private initCanvasGrid;
+    fn_getDataForWidgetComponent(listTables: string[], prmDashboardData: YwDashboardDataInterface[]): any;
+    fn_getDataForWidgetComponent_back(listTables: string[]): any[];
+    loadLayoutFromJSON(prmDashboardConfig: YwDashboardConfigInterface, prmDashboardStyle: YwDashboardStyleInterface): void;
+    saveLayoutToJSON(): YwWidgetLayoutInterface[];
+    fn_btn_addWidget(): void;
+    fn_btn_deleteWidget(): void;
+    fn_btn_lockPositionWidgets(): void;
+    fn_lockPositionWidgets(prmAllIsLocked: boolean): void;
+    fn_btn_updateWidgetControlConfig(idWidget: string): void;
+    fn_btn_updateWidgetControlData(idWidget: string): void;
+    /****************************************************** */
+    eventAddWidget(widgetConfig: YwWidgetConfigInterface, controlConfig: any, controlData: any, item: GridStackWidget): void;
+    eventUpdateWidgetControlConfig(idWidget: string, newControlConfig: any): void;
+    eventUpdateWidgetControlData(idWidget: string, newControlData: any): void;
+    /****************************************************** */
+    handleShowFormFilterDrawer(): void;
+    handleCloseFormFilterDrawer(): void;
+    handleCloseFormDrawer(): void;
+    fnGetDrawerWidth(prm_percent: any): number;
+    onFilterSelectionChange(eventData: any): void;
+    fnUpdateDataControllerBasedOnFilter(filterControlListConfig: YwDashboardWidgetFilterConfigInterface[]): void;
+    eventRemoveWidgetById(widgetId: string): void;
+    eventToggleLockWidget(widgetId: string, shouldLock: boolean): void;
+    eventToggleMaximizeWidget(widgetId: string, shouldMaximize: boolean): void;
+    eventShowFormConfigWidget(widgetId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YwDashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<YwDashboardComponent, "yw-dashboard", never, { "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; "showFilter": { "alias": "showFilter"; "required": false; "isSignal": true; }; "dashboardStyle": { "alias": "dashboardStyle"; "required": false; }; "dashboardConfig": { "alias": "dashboardConfig"; "required": false; }; "dashboardData": { "alias": "dashboardData"; "required": false; }; "dashboardFilterConfig": { "alias": "dashboardFilterConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class YwDashboardWidgetComponent {
+    componentWidgetId: string;
+    typeComponent: string;
+    varShowConfigButtons: boolean;
+    styleWidget: i0.InputSignal<YwWidgetStyleInterface>;
+    instanceStyleWidget: i0.Signal<{
+        widgetBackgroundColor: string | undefined;
+        widgetBorderColor: string | undefined;
+    }>;
+    configWidget: YwWidgetConfigInterface;
+    controlConfig: any;
+    controlData: any;
+    dataWidget: any;
+    isLocked: i0.ModelSignal<boolean>;
+    isMaximized: i0.WritableSignal<boolean>;
+    eventDeleteRequest: i0.OutputEmitterRef<string>;
+    eventLockToggleRequest: i0.OutputEmitterRef<{
+        widgetId: string;
+        shouldLock: boolean;
+    }>;
+    eventMaximizeToggleRequest: i0.OutputEmitterRef<{
+        widgetId: string;
+        shouldMaximize: boolean;
+    }>;
+    eventShowConfigFormRequest: i0.OutputEmitterRef<string>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onDeleteClick(): void;
+    onLockClick(): void;
+    onMaximizeClick(): void;
+    onShowFormConfigClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YwDashboardWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<YwDashboardWidgetComponent, "yw-dashboard-widget", never, { "styleWidget": { "alias": "styleWidget"; "required": false; "isSignal": true; }; "configWidget": { "alias": "configWidget"; "required": false; }; "controlConfig": { "alias": "controlConfig"; "required": false; }; "controlData": { "alias": "controlData"; "required": false; }; "isLocked": { "alias": "isLocked"; "required": false; "isSignal": true; }; }, { "isLocked": "isLockedChange"; "eventDeleteRequest": "eventDeleteRequest"; "eventLockToggleRequest": "eventLockToggleRequest"; "eventMaximizeToggleRequest": "eventMaximizeToggleRequest"; "eventShowConfigFormRequest": "eventShowConfigFormRequest"; }, never, never, true, never>;
+}
+
+interface YwMappingConfig {
+    title: string;
+    xLabelText?: string;
+    yLabelText?: string;
+    provider: string;
+    configData: SingleConfigModel | SingleConfigModel[];
+}
+interface TwTableConfigModel {
+    name: string;
+}
+interface TwJoinConfigModel {
+    join: string;
+}
+type SingleConfigModel = {
+    table?: string | (string | TwTableConfigModel)[];
+    xAxis?: string;
+    yAxis?: string;
+    y2Axis?: string;
+    legends?: YwLegendSttings;
+    joins?: boolean;
+    serie?: string;
+    tooltip?: YwTooltipModel;
+    configJoins?: TwJoinConfigModel[];
+};
+interface YwTooltipModel {
+    enable: boolean;
+    format?: string;
+    header?: string;
+    shared?: boolean;
+}
+interface YwLegendSttings {
+    visible: boolean;
+    position?: 'Top' | 'Bottom' | 'Left' | 'Right';
+}
+/** Alias con la ortografía correcta */
+type YwLegendSettings = YwLegendSttings;
+interface YwComponentData<T = unknown> {
+    data: T;
+}
+interface YwComponentEvent<TPayload = unknown> {
+    type: string;
+    source?: string;
+    payload?: TPayload;
+}
+
+interface ChartDataModel {
+    x: string;
+    y: number | string;
+    y2?: number;
+}
+interface ChartSeriesModel {
+    name: string;
+    dataSource: ChartDataModel[];
+}
+
+interface ChartVariant {
+    type: 'cornerRadius' | "simple";
+    orientation?: 'vertical' | 'horizontal';
+}
+interface ChartolumnFacet {
+    type?: 'Cylinder' | 'Rectangle';
+}
+interface ChartTextConfig {
+    name?: string;
+    nameOver?: string;
+}
+type ColorRuleType$2 = 'threshold' | 'pair' | 'range' | 'custom';
+interface BarRenderConfig {
+    rule: ColorRuleType$2;
+    thresholdValue?: number;
+    minRange?: number;
+    maxRange?: number;
+    trueColor?: string;
+    falseColor?: string;
+}
+interface YwBarMappingConfig extends YwMappingConfig {
+    color?: string;
+    columnFacet?: ChartolumnFacet;
+    ruleColorBar?: BarRenderConfig;
+    columnSpacing?: number;
+    variant?: ChartVariant;
+    border?: {
+        width?: number;
+        color?: string;
+        dashArray?: string;
+    };
+}
+
+declare class BarChartComponent implements OnChanges {
+    chartData: any;
+    config: YwBarMappingConfig;
+    idComponent: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BarChartComponent, "yw-bar-chart", never, { "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "idComponent": { "alias": "idComponent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface CustomTooltipModel {
+    enable: boolean;
+    format?: string;
+    header?: string;
+    shared?: boolean;
+}
+type ColorRuleType$1 = 'threshold' | 'pair' | 'range' | 'custom';
+interface PointRenderConfig {
+    rule: ColorRuleType$1;
+    thresholdValue?: number;
+    minRange?: number;
+    maxRange?: number;
+    trueColor?: string;
+    falseColor?: string;
+}
+interface YwLineMappingConfig extends YwMappingConfig {
+    dashArray?: number;
+    widthLine?: number;
+    ruleColorPoint?: PointRenderConfig;
+    chartoColoredLine?: true;
+    valueOrder?: string;
+}
+
+declare class LineChartComponent {
+    chartData: any;
+    config: YwLineMappingConfig;
+    idComponent: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LineChartComponent, "yw-line-chart", never, { "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "idComponent": { "alias": "idComponent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface YwBubbleMappingConfig extends YwMappingConfig {
+    opacity?: '0.5' | '0.10';
+    emptyPointSettings?: string;
+    ruleColorPoint?: PointRenderBubbleConfig;
+}
+type ColorRuleType = 'threshold' | 'pair' | 'range' | 'custom';
+interface PointRenderBubbleConfig {
+    rule: ColorRuleType;
+    thresholdValue?: number;
+    minRange?: number;
+    maxRange?: number;
+    trueColor?: string;
+    falseColor?: string;
+}
+
+declare class BubbleChartComponent {
+    chartData: any;
+    config: YwBubbleMappingConfig;
+    idComponent: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BubbleChartComponent, "yw-bubble-chart", never, { "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "idComponent": { "alias": "idComponent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type YwPieLabelPosition = 'Inside' | 'Outside';
+type YwPieVariant = {
+    type: 'pie' | 'doughnut' | 'mid';
+};
+type YwPieValueDisplayMode = 'percentage' | 'value' | 'both' | 'none';
+interface YwPieMappingConfig extends YwMappingConfig {
+    /** Variante visual del gráfico */
+    variant?: YwPieVariant;
+    /** Radio general del gráfico. Ej: '70%' */
+    radius?: string;
+    /** Radio interno para el tipo 'Doughnut'. Ej: '40%' */
+    innerRadius?: string;
+    /** Mostrar etiquetas en los slices */
+    showDataLabels?: boolean;
+    /** Posición de la etiqueta en el slice */
+    labelPosition?: YwPieLabelPosition;
+    /** Separar el slice más destacado */
+    explodeSlice?: boolean;
+    /** Índice del slice a separar (0 = primero) */
+    explodeIndex?: number;
+    /** Distancia de separación del slice. Ej: '10%' */
+    explodeOffset?: string;
+    /** Paleta de colores personalizada para los slices */
+    palettes?: string[];
+    /** Altura del gráfico. Ej: '400px' */
+    height?: string;
+    /** Habilita la etiqueta en el centro de la dona (Center View). Default: false */
+    showCenterLabel?: boolean;
+    /** Título de la etiqueta central (ej: 'Total', 'Ventas', 'Taxes') */
+    centerLabelTitle?: string;
+    /** Valor de la etiqueta central (si no se define, calcula la suma total acumulada) */
+    centerLabelValue?: string;
+    /** Tamaño del título central. Default: '14px' */
+    centerLabelTitleSize?: string;
+    /** Tamaño del valor central. Default: '20px' */
+    centerLabelValueSize?: string;
+    /** Color del título central. Default: '#64748b' */
+    centerLabelTitleColor?: string;
+    /** Color del valor central. Default: '#1e293b' */
+    centerLabelValueColor?: string;
+    /** Muestra u oculta el nombre/categoría en la etiqueta de cada área. Default: true */
+    showCategoryName?: boolean;
+    /** Modo de visualización del valor en la etiqueta: porcentaje, valor numérico total, ambos o ninguno. Default: 'both' */
+    valueDisplayMode?: YwPieValueDisplayMode;
+    /** Formato del tooltip (fallback si no se especifica en configData.tooltip.format) */
+    tooltipFormat?: string;
+    /** Mostrar leyenda (fallback si no se especifica en configData.legends.visible) */
+    showLegend?: boolean;
+    /** Posición de leyenda (fallback si no se especifica en configData.legends.position) */
+    legendPosition?: 'Top' | 'Bottom' | 'Left' | 'Right';
+}
+/** Alias retrocompatible */
+type YwPieChartConfig = YwPieMappingConfig;
+interface ChartPieSeriesModelConfig extends ChartSeriesModel {
+    color?: string;
+    innerRadius?: string;
+    startAngle?: number;
+    endAngle?: number;
+    radius?: string;
+}
+/** Alias retrocompatible */
+type YwPieSeriesModelConfig = ChartPieSeriesModelConfig;
+/** Configuración visual procesada para Syncfusion AccumulationChart */
+interface SfPieVisualConfig {
+    legendSettings?: LegendSettingsModel;
+    tooltip?: TooltipSettingsModel;
+    dataLabel?: AccumulationDataLabelSettingsModel;
+}
+/** Configuración de la etiqueta central para la variante Dona */
+interface SfPieCenterLabelConfig {
+    show: boolean;
+    title: string;
+    value: string;
+    titleSize: string;
+    valueSize: string;
+    titleColor: string;
+    valueColor: string;
+}
+/** Resultado estructurado que entrega el adaptador de Pie al componente visual */
+interface PieChartParseResult {
+    series: ChartPieSeriesModelConfig[];
+    visualConfig: SfPieVisualConfig;
+    centerLabel?: SfPieCenterLabelConfig;
+    labelData?: any;
+}
+
+interface SfPiePoint extends ChartDataModel {
+    text?: string;
+    fill?: string;
+}
+
+declare class PieChartComponent {
+    private static _nextId;
+    private _idComponent;
+    set idComponent(val: string);
+    get idComponent(): string;
+    chartData: any;
+    config: YwPieMappingConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PieChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PieChartComponent, "yw-pie-chart", never, { "idComponent": { "alias": "idComponent"; "required": false; }; "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface SfGaugePoint {
+    /** Valor del puntero principal del gauge */
+    value: number;
+    /** Texto de la etiqueta central (ej: '65%', '1250 USD') */
+    text?: string;
+}
+
+/** Determina cómo se agrega el yLabel cuando hay múltiples filas */
+type YwGaugeAggregation = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'first';
+/** Variantes prehechas del Gauge Chart */
+type YwGaugeVariant = {
+    type: 'position' | 'width-range' | 'multi';
+};
+/** Rango de color en el arco del gauge (ej: verde/amarillo/rojo) */
+interface YwGaugeRange {
+    start: number;
+    end: number;
+    color: string;
+    /** Grosor general del rango, por defecto 8 */
+    width?: number;
+    /** Grosor de inicio del rango (para arcos variables) */
+    startWidth?: number;
+    /** Grosor de fin del rango (para arcos variables) */
+    endWidth?: number;
+    /** Radio de curvatura específico para este rango. Si no se especifica, usa el cálculo del gauge */
+    roundedCornerRadius?: number;
+    /** Etiqueta descriptiva de la zona de valor (ej: 'Bajo', 'Medio', 'Alto') */
+    label?: string;
+    /** Identificador de zona opcional */
+    id?: string;
+    /** Opacidad del rango (usado dinámicamente en selección o personalización) */
+    opacity?: number;
+}
+/** Estilo de terminación de los extremos del arco/barra de progreso */
+type YwGaugeCornerStyle = 'round' | 'flat';
+/** Posición de los ticks respecto a la línea de medidas */
+type YwGaugeTickPosition = 'Outside' | 'Inside' | 'Cross';
+interface YwGaugeMappingConfig extends YwMappingConfig {
+    /** Cómo agregar el valor cuando hay múltiples filas ('sum' | 'avg' | 'count' | 'min' | 'max' | 'first'). Default: 'sum' */
+    aggregation?: YwGaugeAggregation;
+    /** Valor mínimo del arco del gauge. Default: 0 */
+    minimum?: number;
+    /** Valor máximo del arco del gauge. Default: 100 */
+    maximum?: number;
+    /** Ángulo de inicio del arco. Default: 270 (arriba) */
+    startAngle?: number;
+    /** Ángulo de fin del arco. Default: 90 */
+    endAngle?: number;
+    /** Rangos de colores sobre el arco (bajo/medio/alto) */
+    ranges?: YwGaugeRange[];
+    /** Color de la aguja/puntero */
+    pointerColor?: string;
+    /** Mostrar el valor como etiqueta central */
+    showLabel?: boolean;
+    /** Formato de la etiqueta central (ej: '{value} USD') */
+    labelFormat?: string;
+    /** Habilitar tooltip al hacer hover (también soportado vía configData.tooltip) */
+    enableTooltip?: boolean;
+    /** Mostrar regla/escala con ticks y valores alrededor del arco. Default: false */
+    showTicks?: boolean;
+    /** Posición de los ticks respecto a la línea de medidas. Default: 'Outside' */
+    tickPosition?: YwGaugeTickPosition;
+    /** Distancia de separación de las etiquetas numéricas para que los ticks queden entre el arco y los números */
+    labelOffset?: number;
+    /** Activar efecto de doble línea tipo líquido (línea de fondo vacío + línea de llenado) */
+    enableProgressTrack?: boolean;
+    /** Color de la línea de fondo / estado vacío. Default: '#E5E7EB' */
+    trackColor?: string;
+    /** Color de la línea de llenado progresivo / líquido. Default: pointerColor o '#0052CC' */
+    progressColor?: string;
+    /** Grosor en px de las líneas de fondo y líquido. Default: 14 */
+    progressWidth?: number;
+    /** Ancho inicial del arco en px para variantes con grosor progresivo (ej: 'width-range'). Default: 4 */
+    startWidth?: number;
+    /** Ancho final del arco en px para variantes con grosor progresivo (ej: 'width-range'). Default: 24 */
+    endWidth?: number;
+    /** Conservar la aguja cuando el modo de llenado líquido esté activo. Default: false */
+    showNeedleWithProgress?: boolean;
+    /** Estilo de terminación de extremos: 'round' (redondo/cápsula) o 'flat' (recto). Default: 'flat' */
+    cornerStyle?: YwGaugeCornerStyle;
+    /** Tamaño de fuente del label central (ej: '24px', 24). Default inteligente según aguja */
+    labelSize?: string | number;
+    /** Aplicar negrita/grosor al label central. Default: true sin aguja, false con aguja */
+    labelBold?: boolean;
+    /** Peso tipográfico específico para el label central ('normal' | 'bold' | '600' | '700') */
+    labelWeight?: string;
+    /** Color de la fuente del label central. Default: '#1F2937' */
+    labelColor?: string;
+    /** Distancia radial desde el centro hasta el label central (ej: '20%', '40%', 25). Default: '20%' sin aguja, '40%' con aguja */
+    labelDistance?: string | number;
+    /** Alias retrocompatible de labelDistance */
+    labelRadius?: string | number;
+    /** Ángulo polar de la etiqueta central respecto al centro. Default: 180 (abajo) */
+    labelAngle?: number;
+    /** Forzar redondeo en todos los rangos en modo multi-rango. Default: false (uniones rectas) */
+    roundMultiRanges?: boolean;
+    variant?: YwGaugeVariant;
+}
+/** Alias retrocompatible */
+type YwGaugeChartConfig = YwGaugeMappingConfig;
+/** Configuración visual ya mapeada por el adaptador, lista para renderizar en Syncfusion CircularGauge */
+interface SfGaugeVisualConfig {
+    title: string;
+    minimum: number;
+    maximum: number;
+    startAngle: number;
+    endAngle: number;
+    ranges: YwGaugeRange[];
+    pointerColor: string;
+    enableTooltip: boolean;
+    showLabel: boolean;
+    labelFormat: string;
+    showTicks: boolean;
+    labelAngle: number;
+    labelRadius: string;
+    tickPosition: 'Outside' | 'Inside' | 'Cross';
+    labelOffset: number;
+    enableProgressTrack: boolean;
+    trackColor: string;
+    progressColor: string;
+    progressWidth: number;
+    showNeedleWithProgress: boolean;
+    cornerStyle: 'round' | 'flat';
+    cornerRadius: number;
+    labelSize: string;
+    labelBold: boolean;
+    labelWeight: string;
+    labelColor: string;
+    roundMultiRanges: boolean;
+    isVariableWidth?: boolean;
+    startWidth?: number;
+    endWidth?: number;
+}
+/** Resultado completo que entrega el adaptador al componente visual */
+interface GaugeChartParseResult {
+    gaugePoint: SfGaugePoint;
+    visualConfig: SfGaugeVisualConfig;
+}
+
+declare class GaugeChartSyncfusionComponent implements OnInit, AfterViewInit, OnChanges, DoCheck, OnDestroy {
+    private cdr;
+    private elRef;
+    gaugeInstance?: CircularGaugeComponent;
+    private _chartData;
+    private _dataSnapshot;
+    private _resizeObserver?;
+    private _currentAnimationId?;
+    private _previousValue?;
+    private _isViewInitialized;
+    private _hasAnimatedInitial;
+    private _isAnimating;
+    private static _nextId;
+    private _idComponent;
+    set idComponent(val: string);
+    get idComponent(): string;
+    set chartData(val: any);
+    get chartData(): any;
+    config: YwGaugeMappingConfig;
+    gaugePoint: SfGaugePoint;
+    visualConfig: SfGaugeVisualConfig;
+    /** Tamaño de fuente dinámico del label central según el tamaño del contenedor */
+    currentLabelSize: string;
+    /** Texto animado del contador central durante la interpolación */
+    animatedLabelText: string;
+    constructor(cdr: ChangeDetectorRef, elRef: ElementRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Evento emitido por Syncfusion cuando el SVG ha culminado su renderizado físico en el DOM.
+     * Garantiza que los elementos <path> existen antes de arrancar la animación de llenado.
+     */
+    onGaugeLoaded(args: any): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    updateParsedData(): void;
+    /**
+     * Configura el ResizeObserver siguiendo el patrón estandarizado del Bar Chart con requestAnimationFrame.
+     */
+    private _setupResizeObserver;
+    /**
+     * Calcula el tamaño de fuente óptimo para el label central en función del ancho del contenedor.
+     */
+    private _updateAdaptiveLabelSize;
+    /**
+     * Genera los dos rangos para la variante cónica (progreso + pista restante con midWidth interpolado).
+     * SIEMPRE produce exactamente 2 rangos para que Syncfusion los registre en el DOM.
+     */
+    private _getVariableWidthRanges;
+    /**
+     * Motor de animación a 60fps con requestAnimationFrame para la variante width-range.
+     * Transiciona desde startVal (0/min) hasta targetVal en duration ms con curva cúbica suave (easeOutCubic).
+     */
+    private _animateWidthRange;
+    private _cancelAnimation;
+    /** Método público para forzar refresco manual */
+    refresh(): void;
+    /** Helper para el trackBy en la plantilla */
+    trackByIndex(index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeChartSyncfusionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeChartSyncfusionComponent, "yw-gauge-chart-syncfusion", never, { "idComponent": { "alias": "idComponent"; "required": false; }; "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GaugeChartComponent implements OnChanges, DoCheck {
+    syncfusionComponent?: GaugeChartSyncfusionComponent;
+    private _chartData;
+    private _dataSnapshot;
+    private static _nextId;
+    private _idComponent;
+    set idComponent(val: string);
+    get idComponent(): string;
+    set chartData(val: any);
+    get chartData(): any;
+    config: YwGaugeMappingConfig;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngDoCheck(): void;
+    /** Método público para forzar refresco manual */
+    refresh(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeChartComponent, "yw-gauge-chart", never, { "idComponent": { "alias": "idComponent"; "required": false; }; "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface JoinItem {
+    join: string;
+}
+interface ConfigJoinOutput {
+    configJoins: JoinItem[];
+}
+declare class TableRelationshipComponent implements OnInit, OnChanges {
+    private fb;
+    private message;
+    chartData: Record<string, any[]>;
+    config?: ConfigJoinOutput;
+    saveRelations: EventEmitter<ConfigJoinOutput>;
+    relationshipForm: FormGroup;
+    resultado?: ConfigJoinOutput;
+    constructor(fb: FormBuilder, message: NzMessageService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    evaluarYcargarConfig(): void;
+    cargarConfiguracionPrevia(joinsArray: JoinItem[]): void;
+    getJoins(): FormArray;
+    getNombresTablas(): string[];
+    getColumnasDeTabla(tableName: string): string[];
+    agregarRelacionItem(): void;
+    eliminarRelacionItem(index: number): void;
+    emitirDatos(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRelationshipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableRelationshipComponent, "yw-table-relationship", never, { "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "saveRelations": "saveRelations"; }, never, never, true, never>;
+}
+
+export { BarChartComponent, BubbleChartComponent, DEFAULT_WIDGET_STYLE, GaugeChartComponent, LineChartComponent, PieChartComponent, SYNCFUSION_CONFIG, TableRelationshipComponent, YwChartsLibraryComponent, YwChartsLibraryService, YwDashboardComponent, YwDashboardWidgetComponent, YwDashboardWidgetFilterTypes, YwDashboardWidgetTypes, provideSyncfusionLicense };
+export type { BarRenderConfig, ChartDataModel, ChartPieSeriesModelConfig, ChartSeriesModel, ChartTextConfig, ChartVariant, ChartolumnFacet, ConfigJoinOutput, CustomTooltipModel, GaugeChartParseResult, JoinItem, PieChartParseResult, PointRenderBubbleConfig, PointRenderConfig, SfGaugePoint, SfGaugeVisualConfig, SfPieCenterLabelConfig, SfPiePoint, SfPieVisualConfig, SingleConfigModel, SyncfusionConfig, TwJoinConfigModel, TwTableConfigModel, YwBarMappingConfig, YwBaseSlicerFilterConfig, YwBubbleMappingConfig, YwButtonSlicerFilterConfig, YwComponentData, YwComponentEvent, YwDashboardConfigInterface, YwDashboardDataInterface, YwDashboardFilterConfigInterface, YwDashboardLayoutInterface, YwDashboardStyleInterface, YwDashboardWidgetFilterConfigInterface, YwGaugeAggregation, YwGaugeChartConfig, YwGaugeCornerStyle, YwGaugeMappingConfig, YwGaugeRange, YwGaugeTickPosition, YwGaugeVariant, YwLegendSettings, YwLegendSttings, YwLineMappingConfig, YwListSlicerFilterConfig, YwMappingConfig, YwPieChartConfig, YwPieLabelPosition, YwPieMappingConfig, YwPieSeriesModelConfig, YwPieValueDisplayMode, YwPieVariant, YwTooltipModel, YwWidgetConfigInterface, YwWidgetFilterConfigInterface, YwWidgetLayoutInterface, YwWidgetStyleInterface };