ngx-sfc-components 0.0.1

package/lib/components/avatar/avatar.component.d.ts

@@ -0,0 +1,42 @@
+import { AfterContentInit, OnInit, QueryList } from '@angular/core';
+import { IAvatarDataModel } from './models/avatar-data.model';
+import { AvatarImageModel } from './models/avatar-image.model';
+import { IAvatarProgressModel } from './models/avatar-progress.model';
+import { AvatarBadgeComponent } from './parts/badge/avatar-badge.component';
+import * as i0 from "@angular/core";
+export declare class AvatarComponent implements OnInit, AfterContentInit {
+    readonly PROGRESS_MODEL_DEFAULT: IAvatarProgressModel;
+    readonly DATA_MODEL_DEFAULT: IAvatarDataModel;
+    readonly STROKE_HOVER_VALUE = 2;
+    readonly FULLNAME_PART_VALUE = 4;
+    readonly TITLE_PART_VALUE = 5;
+    /**
+     * Avatar radius (80 by default)
+     */
+    radius: number;
+    /**
+     * Size of avatar progress circle (2 by default)
+     */
+    stroke: number;
+    /**
+     * Progress value
+     */
+    progress: number;
+    /**
+     * Progress colors model
+     */
+    progressModel: IAvatarProgressModel;
+    data: IAvatarDataModel;
+    stars: boolean;
+    starsValue: number;
+    badges: QueryList<AvatarBadgeComponent>;
+    /**
+     * Avatar image calculated values
+     */
+    imageModel: AvatarImageModel;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    get strokeDashOffset(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "sfc-avatar", never, { "radius": "radius"; "stroke": "stroke"; "progress": "progress"; "progressModel": "progressModel"; "data": "data"; "stars": "stars"; "starsValue": "starsValue"; }, {}, ["badges"], ["*"]>;
+}

package/lib/components/avatar/avatar.constants.d.ts

@@ -0,0 +1,8 @@
+export declare class AvatarConstants {
+    static DEFAULT_RADIUS: number;
+    static DEFAULT_STROKE: number;
+    static STARS_DEFAULT_COUNT: number;
+    static PROGRESS_DEFAULT_COLOR: string;
+    static PROGRESS_DEFAULT_FILLED_COLOR: string;
+    static DATA_DEFAULT_IMAGE: string;
+}

package/lib/components/avatar/models/avatar-data.model.d.ts

@@ -0,0 +1,6 @@
+export interface IAvatarDataModel {
+    firstName?: string;
+    lastName?: string;
+    image?: string;
+    title?: string;
+}

package/lib/components/avatar/models/avatar-image.model.d.ts

@@ -0,0 +1,12 @@
+export declare class AvatarImageModel {
+    private radius;
+    private stroke;
+    private image;
+    NormalizedRadius: number;
+    ImageRadius: number;
+    Circumference: number;
+    Height: number;
+    Width: number;
+    ImageId: string;
+    constructor(radius: number, stroke: number, image: string);
+}

package/lib/components/avatar/models/avatar-progress.model.d.ts

@@ -0,0 +1,4 @@
+export interface IAvatarProgressModel {
+    color?: string;
+    filledColor?: string;
+}

package/lib/components/avatar/parts/badge/avatar-badge-position.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum AvatarBadgePosition {
+    Top = "top",
+    RightTop = "right-top",
+    Right = "right",
+    RightBottom = "right-bottom",
+    Bottom = "bottom",
+    LeftTop = "left-top",
+    Left = "left",
+    LeftBottom = "left-bottom"
+}

package/lib/components/avatar/parts/badge/avatar-badge.component.d.ts

@@ -0,0 +1,14 @@
+import { AvatarBadgePosition } from './avatar-badge-position.enum';
+import * as i0 from "@angular/core";
+export declare class AvatarBadgeComponent {
+    position: AvatarBadgePosition;
+    background?: string;
+    radius: number;
+    normalizedRadius: number;
+    stroke: number;
+    get styles(): any;
+    private get positionStyle();
+    private get sizePart();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarBadgeComponent, "sfc-avatar-badge", never, { "position": "position"; "background": "background"; }, {}, never, ["*"]>;
+}

package/lib/components/avatar/parts/badge/avatar-badge.constants.d.ts

@@ -0,0 +1,4 @@
+export declare class AvatarBadgeConstants {
+    static SIZE_MULTIPLIER: number;
+    static TEXT_SIZE_MULTIPLIER: number;
+}

package/lib/components/carousel/carousel.component.d.ts

@@ -0,0 +1,62 @@
+import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { ResizeService } from 'ngx-sfc-common';
+import { CarouselSlideDirective } from './directive/carousel-slide.directive';
+import { CarouselDOMModel } from './models/dom.model';
+import { CarouselNavigationDotsModel, CarouselNavigationModel } from './models/navigation.model';
+import { CarouselOptionsModel } from './models/options.model';
+import { CarouselSlideModel, CarouselSlideEvent } from './models/slide.model';
+import { CarouselStageModel } from './parts/stage/carousel-stage.model';
+import { CarouselAnimateService } from './service/animate/carousel-animate.service';
+import { CarouselAutoplayService } from './service/autoplay/carousel-autoplay.service';
+import { CarouselService } from './service/carousel/carousel.service';
+import { CarouselLazyLoadService } from './service/lazy/carousel-lazy-load.service';
+import { CarouselNavigationService } from './service/navigation/carousel-navigation.service';
+import * as i0 from "@angular/core";
+export declare class CarouselComponent implements OnInit, AfterContentInit, OnDestroy {
+    private el;
+    private resizeService;
+    private carouselService;
+    private navigationService;
+    private autoplayService;
+    private lazyLoadService;
+    private animateService;
+    private changeDetectorRef;
+    options: CarouselOptionsModel;
+    translated: EventEmitter<CarouselSlideEvent>;
+    initialized: EventEmitter<CarouselSlideEvent>;
+    changing: EventEmitter<CarouselSlideEvent>;
+    changed: EventEmitter<CarouselSlideEvent>;
+    slides: QueryList<CarouselSlideDirective>;
+    private resizeSubscription;
+    private carouselSubscription;
+    private slidesChangesSubscription;
+    carouselDOMModel: CarouselDOMModel;
+    stageModel: CarouselStageModel;
+    slidesModel: CarouselSlideModel[];
+    navigationModel: CarouselNavigationModel;
+    navigationDotsModel: CarouselNavigationDotsModel;
+    slideEvent: CarouselSlideEvent;
+    carouselLoaded: boolean;
+    get rtl(): boolean;
+    get clientWidth(): number;
+    private carouselWindowWidth;
+    private documentRef;
+    constructor(el: ElementRef, resizeService: ResizeService, carouselService: CarouselService, navigationService: CarouselNavigationService, autoplayService: CarouselAutoplayService, lazyLoadService: CarouselLazyLoadService, animateService: CarouselAnimateService, changeDetectorRef: ChangeDetectorRef, documentRef: any);
+    onVisibilityChange(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    initDataStreams(): void;
+    private initResizeWatcher;
+    onTransitionEnd(): void;
+    next(): void;
+    previous(): void;
+    moveByDot(dotId: string): void;
+    pause(): void;
+    play(): void;
+    stopAutoplay(): void;
+    startAutoplay(): void;
+    private gatherTranslatedData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselComponent, "sfc-carousel", never, { "options": "options"; }, { "translated": "translated"; "initialized": "initialized"; "changing": "changing"; "changed": "changed"; }, ["slides"], never>;
+}

package/lib/components/carousel/carousel.enum.d.ts

@@ -0,0 +1,26 @@
+export declare enum CarouselProperty {
+    Position = "position",
+    Settings = "settings",
+    Width = "width",
+    Items = "items"
+}
+export declare enum CarouselState {
+    Busy = "busy",
+    Interacting = "interacting",
+    Rotating = "rotating"
+}
+export declare enum CarouselEventType {
+    Initializing = "initializing",
+    Initialized = "initialized",
+    Change = "change",
+    Changed = "changed",
+    Resize = "resize",
+    Resizing = "resizing",
+    Resized = "resized",
+    Refresh = "refresh",
+    Refreshed = "refreshed",
+    Translate = "translate",
+    Translated = "translated",
+    Animating = "animating",
+    Refreshing = "refreshing"
+}

package/lib/components/carousel/directive/carousel-slide.directive.d.ts

@@ -0,0 +1,13 @@
+import { TemplateRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class CarouselSlideDirective {
+    tplRef: TemplateRef<any>;
+    id: string;
+    private _dataMerge;
+    set dataMerge(data: number);
+    get dataMerge(): number;
+    width: number;
+    constructor(tplRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselSlideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselSlideDirective, "ng-template[sfcCarouselSlide]", never, { "id": "id"; "dataMerge": "dataMerge"; "width": "width"; }, {}, never>;
+}

package/lib/components/carousel/models/dom.model.d.ts

@@ -0,0 +1,7 @@
+export interface CarouselDOMModel {
+    rtl: boolean;
+    isResponsive: boolean;
+    isRefreshed: boolean;
+    isLoaded: boolean;
+    isLoading: boolean;
+}

package/lib/components/carousel/models/navigation.model.d.ts

@@ -0,0 +1,17 @@
+export interface CarouselNavigationButtonModel {
+    disabled: boolean;
+    label: string;
+}
+export interface CarouselNavigationModel {
+    disabled: boolean;
+    previous: CarouselNavigationButtonModel;
+    next: CarouselNavigationButtonModel;
+}
+export interface CarouselNavigationDot {
+    id: string;
+    active: boolean;
+}
+export interface CarouselNavigationDotsModel {
+    disabled: boolean;
+    dots: CarouselNavigationDot[];
+}

package/lib/components/carousel/models/options.model.d.ts

@@ -0,0 +1,40 @@
+export interface CarouselOptions {
+    items?: number;
+    skip_validateItems?: boolean;
+    loop?: boolean;
+    center?: boolean;
+    rewind?: boolean;
+    margin?: number;
+    stagePadding?: number;
+    merge?: boolean;
+    mergeFit?: boolean;
+    autoWidth?: boolean;
+    responsiveRefreshRate?: number;
+    nav?: boolean;
+    navSpeed?: number | boolean;
+    slideBy?: number | string;
+    dots?: boolean;
+    dotsEach?: number | boolean;
+    dotsSpeed?: number | boolean;
+    autoplay?: boolean;
+    autoplayTimeout?: number;
+    autoplaySpeed?: number | boolean;
+    autoplayMouseleaveTimeout?: number;
+    slideTransition?: string;
+    animateOut?: string | boolean;
+    animateIn?: string | boolean;
+    autoHeight?: boolean;
+}
+export interface CarouselResponsiveModel {
+    [key: number]: CarouselOptions;
+}
+export interface CarouselOptionsModel extends CarouselOptions {
+    startPosition?: number | string;
+    rtl?: boolean;
+    responsive?: CarouselResponsiveModel;
+    navText?: string[];
+    navigationDotsModel?: boolean;
+    autoplayHoverPause?: boolean;
+    lazyLoad?: boolean;
+    lazyLoadEager?: number;
+}

package/lib/components/carousel/models/slide.model.d.ts

@@ -0,0 +1,28 @@
+import { TemplateRef } from "@angular/core";
+export interface CarouselSlideModel {
+    id: string;
+    isActive?: boolean;
+    tplRef: TemplateRef<any> | null;
+    dataMerge?: number;
+    width?: number | string;
+    marginL?: number | string;
+    marginR?: number | string;
+    isCentered?: boolean;
+    center?: boolean;
+    isCloned?: boolean;
+    load?: boolean;
+    left?: number | string;
+    classes: {
+        [key: string]: boolean;
+    };
+    isAnimated?: boolean;
+    isDefAnimatedIn?: boolean;
+    isDefAnimatedOut?: boolean;
+    isCustomAnimatedIn?: boolean;
+    isCustomAnimatedOut?: boolean;
+    heightState?: string;
+}
+export interface CarouselSlideEvent {
+    startPosition?: number;
+    slides?: CarouselSlideModel[];
+}

package/lib/components/carousel/parts/stage/carousel-stage.component.d.ts

@@ -0,0 +1,30 @@
+import { CarouselSlideModel } from '../../models/slide.model';
+import { CarouselAnimateService } from '../../service/animate/carousel-animate.service';
+import { CarouselService } from '../../service/carousel/carousel.service';
+import { CarouselStageModel } from './carousel-stage.model';
+import * as i0 from "@angular/core";
+export declare class CarouselStageComponent {
+    private carouselService;
+    private animateService;
+    stageModel: CarouselStageModel;
+    slidesModel: CarouselSlideModel[];
+    get styles(): {
+        width: string;
+        transform: string;
+        transition: string;
+        paddingLeft: string;
+        paddingRight: string;
+    };
+    constructor(carouselService: CarouselService, animateService: CarouselAnimateService);
+    getItemStyles(slide: CarouselSlideModel): {
+        width: string;
+        marginLeft: string;
+        marginRight: string;
+        left: string;
+    };
+    onTransitionEnd(): void;
+    clear(id: string): void;
+    preparePublicSlide: (slide: CarouselSlideModel) => CarouselSlideModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselStageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselStageComponent, "sfc-carousel-stage", never, { "stageModel": "stageModel"; "slidesModel": "slidesModel"; }, {}, never, never>;
+}

package/lib/components/carousel/parts/stage/carousel-stage.model.d.ts

@@ -0,0 +1,7 @@
+export interface CarouselStageModel {
+    transform: string;
+    transition: string;
+    width: number | string;
+    paddingL: number | string;
+    paddingR: number | string;
+}

package/lib/components/carousel/service/animate/carousel-animate.service.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy } from '@angular/core';
+import { CarouselService } from '../carousel/carousel.service';
+import * as i0 from "@angular/core";
+export declare class CarouselAnimateService implements OnDestroy {
+    private carouselService;
+    private swapping;
+    private previous?;
+    private next;
+    private animateSubscription;
+    constructor(carouselService: CarouselService);
+    ngOnDestroy(): void;
+    private initDataStreams;
+    private swap;
+    clear(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselAnimateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CarouselAnimateService>;
+}

package/lib/components/carousel/service/autoplay/carousel-autoplay.service.d.ts

@@ -0,0 +1,29 @@
+import { OnDestroy } from '@angular/core';
+import { CarouselService } from '../carousel/carousel.service';
+import * as i0 from "@angular/core";
+export declare class CarouselAutoplayService implements OnDestroy {
+    private carouselService;
+    private autoplaySubscription;
+    private timeout;
+    private paused;
+    private isArtificialAutoplayTimeout;
+    private _isAutoplayStopped;
+    get isAutoplayStopped(): boolean;
+    set isAutoplayStopped(value: boolean);
+    private winRef;
+    private docRef;
+    constructor(carouselService: CarouselService, winRef: any, docRef: any);
+    ngOnDestroy(): void;
+    play(): void;
+    stop(): void;
+    pause(): void;
+    startPausing(): void;
+    startPlayingMouseLeave(): void;
+    private initDataStreams;
+    private getNextTimeout;
+    private setAutoPlayInterval;
+    private handleChangeObservable;
+    private playAfterTranslated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselAutoplayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CarouselAutoplayService>;
+}

package/lib/components/carousel/service/carousel/carousel-service.constants.d.ts

@@ -0,0 +1,5 @@
+import { CarouselOptionsModel } from "../../models/options.model";
+export declare class CarouselServiceConstants {
+    static CLONE_ID_PREFIX: string;
+    static DEFAULT_OPTIONS: CarouselOptionsModel;
+}

package/lib/components/carousel/service/carousel/carousel-service.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum Type {
+    Event = "event",
+    State = "state"
+}
+export declare enum Width {
+    Default = "default",
+    Inner = "inner",
+    Outer = "outer"
+}

package/lib/components/carousel/service/carousel/carousel-service.model.d.ts

@@ -0,0 +1,21 @@
+import { CarouselDOMModel } from "../../models/dom.model";
+import { CarouselNavigationDotsModel, CarouselNavigationModel } from "../../models/navigation.model";
+import { CarouselSlideModel } from "../../models/slide.model";
+import { CarouselStageModel } from "../../parts/stage/carousel-stage.model";
+export interface States {
+    current: {};
+    tags: {
+        [key: string]: string[];
+    };
+}
+export interface Coords {
+    x: number;
+    y: number;
+}
+export interface CarouselCurrentData {
+    carouselDOMModel: CarouselDOMModel;
+    stageModel: CarouselStageModel;
+    slidesModel: CarouselSlideModel[];
+    navigationModel: CarouselNavigationModel;
+    navigationDotsModel: CarouselNavigationDotsModel;
+}

package/lib/components/carousel/service/carousel/carousel.service.d.ts

@@ -0,0 +1,92 @@
+import { Observable } from 'rxjs';
+import { CarouselSlideDirective } from '../../directive/carousel-slide.directive';
+import { CarouselNavigationDotsModel, CarouselNavigationModel } from '../../models/navigation.model';
+import { CarouselOptionsModel } from '../../models/options.model';
+import { CarouselSlideModel } from '../../models/slide.model';
+import { CarouselCurrentData } from './carousel-service.model';
+import * as i0 from "@angular/core";
+export declare class CarouselService {
+    private _viewSettingsShipper$;
+    private _initializedCarousel$;
+    private _changeSettingsCarousel$;
+    private _changedSettingsCarousel$;
+    private _translateCarousel$;
+    private _translatedCarousel$;
+    private _resizeCarousel$;
+    private _resizedCarousel$;
+    private _refreshCarousel$;
+    private _refreshedCarousel$;
+    private carouselDOMModel;
+    private stageModel;
+    private _width;
+    private _items;
+    private _widths;
+    private _supress;
+    private _current;
+    private _clones;
+    private _mergers;
+    private _speed;
+    private _coordinates;
+    private _invalidated;
+    private _states;
+    private _pipe;
+    settings: CarouselOptionsModel;
+    slidesModel: CarouselSlideModel[];
+    navigationModel: CarouselNavigationModel;
+    navigationDotsModel: CarouselNavigationDotsModel;
+    options: CarouselOptionsModel;
+    get viewCurrrentSettings(): Observable<CarouselCurrentData>;
+    get initializedState(): Observable<string>;
+    get changeState(): Observable<any>;
+    get changedState(): Observable<any>;
+    get translateState(): Observable<string>;
+    get translatedState(): Observable<string>;
+    get resizeState(): Observable<string>;
+    get resizedState(): Observable<string>;
+    get refreshState(): Observable<string>;
+    get refreshedState(): Observable<string>;
+    setup(carouselWidth: number, slides: CarouselSlideDirective[], options: CarouselOptionsModel): void;
+    initialize(slides: CarouselSlideDirective[]): void;
+    sendChanges(): void;
+    onResize(curWidth: number): void;
+    is(state: string): boolean;
+    current(position?: number): number | undefined;
+    relative(position: number): number;
+    maximum(relative?: boolean): number;
+    minimum(relative?: boolean): number;
+    items(position?: number): CarouselSlideDirective[];
+    mergers(position: number): number | number[];
+    clones(position?: number): number[];
+    speed(speed?: number): number;
+    coordinates(position: number | null | undefined): number | number[];
+    to(position: number, speed: number | boolean): void;
+    next(speed: number | boolean): void;
+    previous(speed: number | boolean): void;
+    onTransitionEnd(event?: any): void;
+    setCurrentSlideClasses(slide: CarouselSlideModel): {
+        [key: string]: boolean;
+    };
+    enter(name: string): void;
+    leave(name: string): void;
+    private setOptions;
+    private validateItems;
+    private setCarouselWidth;
+    private setOptionsForViewport;
+    private optionsLogic;
+    private update;
+    private width;
+    private refresh;
+    private animate;
+    private invalidate;
+    private reset;
+    private normalize;
+    private duration;
+    private setItems;
+    private defineSlidesData;
+    private op;
+    private trigger;
+    private suppress;
+    private release;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CarouselService>;
+}

package/lib/components/carousel/service/lazy/carousel-lazy-load.service.d.ts

@@ -0,0 +1,14 @@
+import { OnDestroy } from '@angular/core';
+import { CarouselService } from '../carousel/carousel.service';
+import * as i0 from "@angular/core";
+export declare class CarouselLazyLoadService implements OnDestroy {
+    private carouselService;
+    private lazyLoadSubscription;
+    constructor(carouselService: CarouselService);
+    ngOnDestroy(): void;
+    private initDataStreams;
+    private defineLazyLoadSlides;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselLazyLoadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CarouselLazyLoadService>;
+}

package/lib/components/carousel/service/navigation/carousel-navigation.service.d.ts

@@ -0,0 +1,28 @@
+import { OnDestroy } from '@angular/core';
+import { CarouselService } from '../carousel/carousel.service';
+import * as i0 from "@angular/core";
+export declare class CarouselNavigationService implements OnDestroy {
+    private carouselService;
+    private navSubscription;
+    private pages;
+    private navigationModel;
+    private navigationDotsModel;
+    constructor(carouselService: CarouselService);
+    ngOnDestroy(): void;
+    next(speed: number | boolean): void;
+    previous(speed: number | boolean): void;
+    to(position: number, speed: number | boolean, standard?: boolean): void;
+    moveByDot(dotId: string): void;
+    toSlideById(id: string): void;
+    private initDataStreams;
+    private initialize;
+    private updateNavPages;
+    private draw;
+    private update;
+    private updateNavButtons;
+    private updateDots;
+    private getCurrent;
+    private getPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CarouselNavigationService>;
+}

package/lib/components/chart/chart-option.model.d.ts

@@ -0,0 +1,9 @@
+export interface ChartOptionModel {
+    legend?: boolean;
+    gridLines?: boolean;
+    xAxe?: boolean;
+    yAxe?: boolean;
+    tooltip?: boolean;
+    ticks?: boolean;
+    defaultColors?: boolean;
+}

package/lib/components/chart/chart.component.d.ts

@@ -0,0 +1,38 @@
+import { AfterViewInit, NgZone, OnDestroy, OnInit } from '@angular/core';
+import { ChartConfiguration, ChartType, DefaultDataPoint } from 'chart.js';
+import { Theme } from 'ngx-sfc-common';
+import { ChartOptionModel } from './chart-option.model';
+import { ChartSettingsService } from './service/settings/chart-settings.service';
+import { ChartThemeService } from './service/theme/chart-theme.service';
+import * as i0 from "@angular/core";
+export declare class ChartComponent<TType extends ChartType = ChartType, TData = DefaultDataPoint<TType>, TLabel = unknown> implements OnInit, AfterViewInit, OnDestroy {
+    private zone;
+    private themeService;
+    private settingsService;
+    type: ChartConfiguration<TType, TData, TLabel>['type'];
+    data: ChartConfiguration<TType, TData, TLabel>['data'];
+    options: ChartConfiguration<TType, TData, TLabel>['options'];
+    plugins?: ChartConfiguration<TType, TData, TLabel>['plugins'];
+    labels?: ChartConfiguration<TType, TData, TLabel>['data']['labels'];
+    datasets?: ChartConfiguration<TType, TData, TLabel>['data']['datasets'];
+    chartOptions: ChartOptionModel;
+    get theme(): Theme;
+    set theme(value: Theme);
+    private _theme;
+    private canvas;
+    private chart?;
+    private _themeSubscription?;
+    private get themeOptions();
+    constructor(zone: NgZone, themeService: ChartThemeService, settingsService: ChartSettingsService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    update(): void;
+    private getChartConfiguration;
+    private getChartData;
+    private getChartOptions;
+    private overrideDefaultOptionsByModel;
+    private updateColors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent<any, any, any>, "sfc-chart", never, { "type": "type"; "data": "data"; "options": "options"; "plugins": "plugins"; "labels": "labels"; "datasets": "datasets"; "chartOptions": "chartOptions"; "theme": "theme"; }, {}, never, never>;
+}