matcha-components 19.139.0 → 20.1.0

package/index.d.ts

@@ -1,5 +1,1505 @@
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, AfterContentInit, QueryList, OnDestroy, ElementRef, OnChanges, SimpleChanges, Renderer2, ChangeDetectorRef, AfterViewInit, TemplateRef, NgZone, ApplicationRef, Injector, RendererFactory2, Type, ComponentRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i3 from '@angular/forms';
+import { FormControlName, ControlValueAccessor, NgControl } from '@angular/forms';
+import * as i2 from '@angular/common';
+
+declare class MatchaAccordionItemComponent implements OnInit {
+    private _stretch;
+    private _isOpen;
+    set stretch(value: boolean | string);
+    get stretch(): boolean;
+    set isOpen(value: boolean | string);
+    get isOpen(): boolean;
+    opened: EventEmitter<boolean>;
+    ngOnInit(): void;
+    toggleAccordion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAccordionItemComponent, "matcha-accordion-item", never, { "stretch": { "alias": "stretch"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "opened": "opened"; }, never, ["matcha-accordion-header", "matcha-accordion-content", "*"], false, never>;
+}
+
+declare class MatchaAccordionComponent implements AfterContentInit {
+    private _multiple;
+    set multiple(value: boolean | string);
+    get multiple(): boolean;
+    openedChange: EventEmitter<boolean>;
+    items: QueryList<MatchaAccordionItemComponent>;
+    ngAfterContentInit(): void;
+    toggleItem(selectedItem: MatchaAccordionItemComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAccordionComponent, "matcha-accordion", never, { "multiple": { "alias": "multiple"; "required": false; }; }, { "openedChange": "openedChange"; }, ["items"], ["*"], false, never>;
+}
+
+declare class MatchaAccordionHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAccordionHeaderComponent, "matcha-accordion-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaAccordionContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAccordionContentComponent, "matcha-accordion-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaInfiniteScrollComponent implements OnInit, OnDestroy {
+    private element;
+    scrolledToEnd: EventEmitter<void>;
+    private observer;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaInfiniteScrollComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaInfiniteScrollComponent, "matcha-infinite-scroll", never, {}, { "scrolledToEnd": "scrolledToEnd"; }, never, never, false, never>;
+}
+
+declare class MatchaInfiniteScrollDataComponent implements OnInit, OnDestroy, OnChanges {
+    private element;
+    /**
+     * Função que carrega os dados com base no número da página.
+     * Deve retornar um Observable com um array de itens.
+     */
+    loadData: (page: number) => Observable<any[]>;
+    /**
+     * Lista inicial (opcional) para iniciar a agregação.
+     */
+    initialList: any[];
+    /**
+     * Threshold para o Intersection Observer (padrão: 0.1 = 10% do elemento visível).
+     */
+    threshold: number;
+    /**
+     * Chave para resetar a diretiva (para componentes como select).
+     */
+    resetKey: any;
+    /**
+     * Novo input para o autocomplete, onde será aplicado o debounce.
+     */
+    searchTerm: any;
+    /**
+     * Emite a lista acumulada de itens.
+     */
+    aggregatedData: EventEmitter<any[]>;
+    /**
+     * Emite o item exato, quando a aggregatedData tiver um único item igual ao searchTerm.
+     */
+    exactMatch: EventEmitter<any>;
+    private aggregatedList;
+    private currentPage;
+    private observer;
+    private dataSubscription;
+    private searchSubscription;
+    private searchTermSubject;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Inicializa ou reinicializa a lista agregada e o contador de página.
+     */
+    private initialize;
+    /**
+     * Reseta apenas as assinaturas e o estado dos dados (não a inscrição do searchTerm).
+     */
+    private resetData;
+    /**
+     * Carrega a próxima página de dados utilizando a função loadData.
+     */
+    private loadNextPage;
+    /**
+     * Verifica se a lista agregada possui exatamente um item e se esse item é igual ao searchTerm.
+     * Se sim, emite o output exactMatch com esse item.
+     */
+    private checkExactMatch;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaInfiniteScrollDataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaInfiniteScrollDataComponent, "matcha-infinite-scroll-data", never, { "loadData": { "alias": "loadData"; "required": false; }; "initialList": { "alias": "initialList"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "resetKey": { "alias": "resetKey"; "required": false; }; "searchTerm": { "alias": "searchTerm"; "required": false; }; }, { "aggregatedData": "aggregatedData"; "exactMatch": "exactMatch"; }, never, never, false, never>;
+}
+
+declare class MatchaLazyloadComponent implements OnInit, OnDestroy {
+    private element;
+    scrolledToEnd: EventEmitter<void>;
+    private observer;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaLazyloadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaLazyloadComponent, "matcha-lazyload", never, {}, { "scrolledToEnd": "scrolledToEnd"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaLazyloadDataComponent implements OnInit, OnDestroy, OnChanges {
+    private element;
+    /**
+     * Função que carrega os dados com base no número da página.
+     * Deve retornar um Observable com um array de itens.
+     */
+    loadData: (page: number) => Observable<any[]>;
+    /**
+     * Lista inicial (opcional) para iniciar a agregação.
+     */
+    initialList: any[];
+    /**
+     * Threshold para o Intersection Observer (padrão: 0.1 = 10% do elemento visível).
+     */
+    threshold: number;
+    /**
+     * Root margin para o Intersection Observer (padrão: '0px').
+     * Use valores como '100px' para acionar 100px antes do elemento aparecer.
+     * Aceita valores como: '10px', '10px 20px', '10% 5% 0px 5%'
+     */
+    rootMargin: string;
+    /**
+     * Chave para resetar a diretiva (para componentes como select).
+     */
+    resetKey: any;
+    /**
+     * Novo input para o autocomplete, onde será aplicado o debounce.
+     */
+    searchTerm: any;
+    /**
+     * Emite a lista acumulada de itens.
+     */
+    aggregatedData: EventEmitter<any[]>;
+    /**
+     * Emite o item exato, quando a aggregatedData tiver um único item igual ao searchTerm.
+     */
+    exactMatch: EventEmitter<any>;
+    private aggregatedList;
+    private currentPage;
+    private observer;
+    private dataSubscription;
+    private searchSubscription;
+    private searchTermSubject;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Inicializa ou reinicializa a lista agregada e o contador de página.
+     */
+    private initialize;
+    /**
+     * Reseta apenas as assinaturas e o estado dos dados (não a inscrição do searchTerm).
+     */
+    private resetData;
+    /**
+     * Carrega a próxima página de dados utilizando a função loadData.
+     */
+    private loadNextPage;
+    /**
+     * Verifica se a lista agregada possui exatamente um item e se esse item é igual ao searchTerm.
+     * Se sim, emite o output exactMatch com esse item.
+     */
+    private checkExactMatch;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaLazyloadDataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaLazyloadDataComponent, "matcha-lazyload-data", never, { "loadData": { "alias": "loadData"; "required": false; }; "initialList": { "alias": "initialList"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "rootMargin": { "alias": "rootMargin"; "required": false; }; "resetKey": { "alias": "resetKey"; "required": false; }; "searchTerm": { "alias": "searchTerm"; "required": false; }; }, { "aggregatedData": "aggregatedData"; "exactMatch": "exactMatch"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaButtonComponent implements OnChanges, OnInit {
+    private _elementRef;
+    private _renderer;
+    size: string | null;
+    sizeXs: string | null;
+    sizeSm: string | null;
+    sizeMd: string | null;
+    sizeLg: string | null;
+    sizeXl: string | null;
+    color: string | null;
+    get colorAttr(): string | null;
+    private _basic;
+    get basic(): boolean | string;
+    set basic(v: boolean | string);
+    private _outline;
+    get outline(): boolean | string;
+    set outline(v: boolean | string);
+    private _alpha;
+    get alpha(): boolean | string;
+    set alpha(v: boolean | string);
+    private _pill;
+    get pill(): boolean | string;
+    set pill(v: boolean | string);
+    private _link;
+    get link(): boolean | string;
+    set link(v: boolean | string);
+    private _icon;
+    get icon(): boolean | string;
+    set icon(v: boolean | string);
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    private _config;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private clearConfig;
+    private setConfig;
+    private setSize;
+    private setOutline;
+    private setPill;
+    private setLink;
+    private setBasic;
+    private setIcon;
+    private addRippleEffect;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaButtonComponent, "[matcha-button]", never, { "size": { "alias": "size"; "required": false; }; "sizeXs": { "alias": "size-xs"; "required": false; }; "sizeSm": { "alias": "size-sm"; "required": false; }; "sizeMd": { "alias": "size-md"; "required": false; }; "sizeLg": { "alias": "size-lg"; "required": false; }; "sizeXl": { "alias": "size-xl"; "required": false; }; "color": { "alias": "color"; "required": false; }; "basic": { "alias": "basic"; "required": false; }; "outline": { "alias": "outline"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; "pill": { "alias": "pill"; "required": false; }; "link": { "alias": "link"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaCardComponent {
+    private _color;
+    get color(): string | null;
+    set color(v: string | null);
+    get colorAttr(): string | null;
+    blockquote: 'left' | 'right' | 'none' | null;
+    blockquoteColor: string | null;
+    class: string | null;
+    private _alpha;
+    get alpha(): boolean | string;
+    set alpha(v: boolean | string);
+    private _tint;
+    get tint(): boolean | string;
+    set tint(v: boolean | string);
+    private _loading;
+    get loading(): boolean | string;
+    set loading(v: boolean | string);
+    get classes(): string;
+    hasBlockquotePosition(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaCardComponent, "matcha-card", never, { "color": { "alias": "color"; "required": false; }; "blockquote": { "alias": "blockquote"; "required": false; }; "blockquoteColor": { "alias": "blockquoteColor"; "required": false; }; "class": { "alias": "class"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; "tint": { "alias": "tint"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaDividerComponent {
+    gap: string | number | null;
+    gapSm: string | number | null;
+    gapMd: string | number | null;
+    gapLg: string | number | null;
+    gapXl: string | number | null;
+    private _vertical;
+    set vertical(value: boolean | string);
+    get vertical(): boolean;
+    get classes(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDividerComponent, "matcha-divider", never, { "gap": { "alias": "gap"; "required": false; }; "gapSm": { "alias": "gap-sm"; "required": false; }; "gapMd": { "alias": "gap-md"; "required": false; }; "gapLg": { "alias": "gap-lg"; "required": false; }; "gapXl": { "alias": "gap-xl"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface ILevelClasses {
+    [key: number | string]: string;
+}
+declare class MatchaTitleComponent {
+    color: null | string;
+    size: number | string;
+    loading: boolean;
+    type: 'pill' | 'bullet' | 'icon' | 'none';
+    icon: string;
+    iconClick: EventEmitter<object>;
+    sizeClasses: ILevelClasses;
+    getTypes(): string;
+    get signClasses(): string;
+    get textClasses(): string;
+    emitIconAction(): void;
+    hasIconClickOutput(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaTitleComponent, "matcha-title", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "iconClick": "iconClick"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaIconComponent {
+    name: string | undefined | null;
+    size: string | undefined | null;
+    color: string | undefined | null;
+    class: string | undefined | null;
+    loading: boolean | string;
+    get classes(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaIconComponent, "matcha-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "class": { "alias": "class"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaGridComponent {
+    private el;
+    private renderer;
+    breakpoint: string;
+    col: string;
+    gap: string;
+    class: string;
+    span: string;
+    rowspan: string;
+    colspan: string;
+    direction: string;
+    loading: boolean | string;
+    private getStringSplited;
+    private getGridClasses;
+    setColspanClasses(span: string, breakpoint: string): void;
+    setRowspanClasses(span: string, breakpoint: string): void;
+    get classes(): string;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaGridComponent, "matcha-grid", never, { "breakpoint": { "alias": "breakpoint"; "required": false; }; "col": { "alias": "col"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "class": { "alias": "class"; "required": false; }; "span": { "alias": "span"; "required": false; }; "rowspan": { "alias": "rowspan"; "required": false; }; "colspan": { "alias": "colspan"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaMasonryComponent {
+    colSize: string | number | null;
+    smColSize: string | number | null;
+    mdColSize: string | number | null;
+    lgColSize: string | number | null;
+    xlColSize: string | number | null;
+    gap: string | number | null;
+    gapSm: string | number | null;
+    gapMd: string | number | null;
+    gapLg: string | number | null;
+    gapXl: string | number | null;
+    get classes(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaMasonryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaMasonryComponent, "matcha-masonry", never, { "colSize": { "alias": "col"; "required": false; }; "smColSize": { "alias": "col-sm"; "required": false; }; "mdColSize": { "alias": "col-md"; "required": false; }; "lgColSize": { "alias": "col-lg"; "required": false; }; "xlColSize": { "alias": "col-xl"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "gapSm": { "alias": "gap-sm"; "required": false; }; "gapMd": { "alias": "gap-md"; "required": false; }; "gapLg": { "alias": "gap-lg"; "required": false; }; "gapXl": { "alias": "gap-xl"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaModalContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaModalContentComponent, "matcha-modal-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaModalHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaModalHeaderComponent, "matcha-modal-header", never, {}, {}, never, ["*", "matcha-modal-options"], false, never>;
+}
+
+declare class MatchaModalFooterComponent {
+    buttonType: number | string;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaModalFooterComponent, "matcha-modal-footer", never, { "buttonType": { "alias": ""; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaModalOptionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaModalOptionsComponent, "matcha-modal-options", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaModalComponent {
+    size: string | null;
+    sizeXs: string | null;
+    sizeSm: string | null;
+    sizeMd: string | null;
+    sizeLg: string | null;
+    sizeXl: string | null;
+    class: string;
+    hasBackdrop: boolean;
+    backdropClass: string;
+    get sizeAttr(): string | null;
+    get sizeAttrXs(): string | null;
+    get sizeAttrSm(): string | null;
+    get sizeAttrMd(): string | null;
+    get sizeAttrLg(): string | null;
+    get sizeAttrXl(): string | null;
+    get classes(): string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaModalComponent, "matcha-modal", never, { "size": { "alias": "size"; "required": false; }; "sizeXs": { "alias": "size-xs"; "required": false; }; "sizeSm": { "alias": "size-sm"; "required": false; }; "sizeMd": { "alias": "size-md"; "required": false; }; "sizeLg": { "alias": "size-lg"; "required": false; }; "sizeXl": { "alias": "size-xl"; "required": false; }; "class": { "alias": "class"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaMenuComponent {
+    private _elementRef;
+    private _renderer;
+    isParentMenu: boolean;
+    isOpen: boolean;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    handleOutsideClick(event: Event): void;
+    handleMouseLeave(event: MouseEvent): void;
+    openMenu(): void;
+    closeMenu(): void;
+    toggleMenu(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaMenuComponent, "matcha-menu", ["matchaMenu"], { "isParentMenu": { "alias": "isParentMenu"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaToolbarComponent implements OnInit, OnDestroy {
+    isMobileScreen: boolean;
+    private readonly mobileBreakpoint;
+    private resizeTimeout;
+    ngOnInit(): void;
+    onResize(): void;
+    private checkScreenWidth;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaToolbarComponent, "matcha-toolbar", never, {}, {}, never, ["matcha-toolbar-main-button", "matcha-toolbar-custom-button", "matcha-title", "search-form", "matcha-toolbar-button", "matcha-toolbar-content", "*"], false, never>;
+}
+
+declare class MatchaToolbarButtonComponent {
+    icon: string;
+    buttonClick: EventEmitter<any>;
+    get classes(): string;
+    emitButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaToolbarButtonComponent, "matcha-toolbar-button", never, { "icon": { "alias": "icon"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
+}
+
+declare class MatchaToolbarContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaToolbarContentComponent, "matcha-toolbar-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaToolbarMainButtonComponent {
+    buttonClick: EventEmitter<any>;
+    emitButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarMainButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaToolbarMainButtonComponent, "matcha-toolbar-main-button", never, {}, { "buttonClick": "buttonClick"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaToolbarCustomButtonComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarCustomButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaToolbarCustomButtonComponent, "matcha-toolbar-custom-button", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaFormFieldComponent {
+    color: 'red' | 'pink' | 'purple' | 'deep-purple' | 'indigo' | 'blue' | 'light-blue' | 'cyan' | 'teal' | 'green' | 'light-green' | 'lime' | 'yellow' | 'amber' | 'orange' | 'deep-orange' | 'primary' | 'accent' | 'warn' | 'brown' | 'grey' | 'blue-grey' | 'primary' | 'accent' | 'warn';
+    size: string | null;
+    sizeXs: string | null;
+    sizeSm: string | null;
+    sizeMd: string | null;
+    sizeLg: string | null;
+    sizeXl: string | null;
+    controlDir?: FormControlName;
+    get control(): i3.FormControl<any> | undefined;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaFormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaFormFieldComponent, "matcha-form-field", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "sizeXs": { "alias": "size-xs"; "required": false; }; "sizeSm": { "alias": "size-sm"; "required": false; }; "sizeMd": { "alias": "size-md"; "required": false; }; "sizeLg": { "alias": "size-lg"; "required": false; }; "sizeXl": { "alias": "size-xl"; "required": false; }; }, {}, ["controlDir"], ["matcha-label", "*", "matcha-error", "matcha-autocomplete"], false, never>;
+}
+
+declare class MatchaLabelComponent {
+    color: 'red' | 'pink' | 'purple' | 'deep-purple' | 'indigo' | 'blue' | 'light-blue' | 'cyan' | 'teal' | 'green' | 'light-green' | 'lime' | 'yellow' | 'amber' | 'orange' | 'deep-orange' | 'primary' | 'accent' | 'warn' | 'brown' | 'grey' | 'blue-grey' | 'primary' | 'accent' | 'warn';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaLabelComponent, "matcha-label", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaErrorComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaErrorComponent, "matcha-error", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaCheckboxComponent implements ControlValueAccessor {
+    color: string;
+    indeterminate: boolean;
+    private _disabled;
+    set disabled(value: boolean | string);
+    get disabled(): boolean;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    checkedChange: EventEmitter<{
+        checked: boolean;
+    }>;
+    change: EventEmitter<Event>;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaCheckboxComponent, "matcha-checkbox", never, { "color": { "alias": "color"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; "change": "change"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaSpinComponent {
+    private _elementRef;
+    private _renderer;
+    private _progress;
+    set progress(value: string | number);
+    get progress(): string | number;
+    color: string;
+    size: string | null;
+    sizeXs: string | null;
+    sizeSm: string | null;
+    sizeMd: string | null;
+    sizeLg: string | null;
+    sizeXl: string | null;
+    readonly strokeWidth: number;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    ngOnInit(): void;
+    private setSize;
+    get diameter(): number;
+    get radius(): number;
+    get circumference(): number;
+    get dashOffset(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSpinComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaSpinComponent, "matcha-spin", never, { "progress": { "alias": "progress"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "sizeXs": { "alias": "size-xs"; "required": false; }; "sizeSm": { "alias": "size-sm"; "required": false; }; "sizeMd": { "alias": "size-md"; "required": false; }; "sizeLg": { "alias": "size-lg"; "required": false; }; "sizeXl": { "alias": "size-xl"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaSpinnerComponent {
+    private _elementRef;
+    private _renderer;
+    private _progress;
+    set progress(value: string | number);
+    get progress(): string | number;
+    color: string;
+    size: string | null;
+    sizeXs: string | null;
+    sizeSm: string | null;
+    sizeMd: string | null;
+    sizeLg: string | null;
+    sizeXl: string | null;
+    readonly diameter = 66;
+    readonly center = 33;
+    readonly radius = 30;
+    readonly strokeWidth = 5;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    ngOnInit(): void;
+    private setSize;
+    get circumference(): number;
+    get dashOffset(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaSpinnerComponent, "matcha-spinner", never, { "progress": { "alias": "progress"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "sizeXs": { "alias": "size-xs"; "required": false; }; "sizeSm": { "alias": "size-sm"; "required": false; }; "sizeMd": { "alias": "size-md"; "required": false; }; "sizeLg": { "alias": "size-lg"; "required": false; }; "sizeXl": { "alias": "size-xl"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaHintTextComponent {
+    type: 'error' | 'warning' | 'info' | 'success';
+    size: 'tiny' | 'medium';
+    get iconName(): string;
+    get iconColor(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaHintTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaHintTextComponent, "matcha-hint-text", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaSkeletonComponent {
+    amount: number | string;
+    grid: number | string;
+    height: number | string;
+    model: 'profile' | 'table' | 'empty' | string | null;
+    gap: number | string;
+    get classes(): string;
+    get heightClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaSkeletonComponent, "matcha-skeleton", never, { "amount": { "alias": "amount"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; "height": { "alias": "height"; "required": false; }; "model": { "alias": "model"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaOptionService {
+    private _optionsSubject;
+    options$: rxjs.Observable<MatchaOptionComponent[]>;
+    private _activeOptionSubject;
+    activeOption$: rxjs.Observable<number>;
+    private _canShowOptionsSubject;
+    canShowOptions$: rxjs.Observable<boolean>;
+    private _selectedOptionSubject;
+    selectedOption$: rxjs.Observable<string>;
+    constructor();
+    setSelectedOption(selectedOption: string): void;
+    getCanShowOptions(): boolean;
+    setCanShowOptions(canShowOptions: boolean): void;
+    updateOptions(options: MatchaOptionComponent[]): void;
+    updateActiveOption(activeOption: number): void;
+    resetActiveOption(): void;
+    removeActiveOption(): void;
+    changeActiveOption(stepsToMove: number): void;
+    selectActiveOption(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaOptionService>;
+}
+
+declare class MatchaOptionComponent {
+    private changeDetectorRef;
+    private matchaOptionService;
+    value: any;
+    isOptionActive: boolean;
+    constructor(changeDetectorRef: ChangeDetectorRef, matchaOptionService: MatchaOptionService);
+    selectOption(): void;
+    setIsOptionActive(isOptionActive: boolean, isMouseEvent: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaOptionComponent, "matcha-option", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaAutocompleteComponent implements AfterContentInit {
+    private changeDetectorRef;
+    private matchaOptionService;
+    options: QueryList<MatchaOptionComponent>;
+    isDisplayAutocomplete: boolean;
+    activeOption: number;
+    constructor(changeDetectorRef: ChangeDetectorRef, matchaOptionService: MatchaOptionService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAutocompleteComponent, "matcha-autocomplete", never, {}, {}, ["options"], ["*"], false, never>;
+}
+
+declare class MatchaSlideToggleComponent implements ControlValueAccessor, OnChanges, AfterViewInit {
+    private elementRef;
+    color: string;
+    private _checked;
+    set checked(value: boolean | string);
+    get checked(): boolean;
+    private _disabled;
+    set disabled(value: boolean | string);
+    get disabled(): boolean;
+    change: EventEmitter<{
+        checked: boolean;
+    }>;
+    onChange: (value: boolean) => void;
+    onTouched: () => void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    onInputChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSlideToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaSlideToggleComponent, "matcha-slide-toggle", never, { "color": { "alias": "color"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaButtonToggleComponent implements AfterContentInit {
+    private elementRef;
+    private _multiple;
+    get multiple(): boolean | string;
+    set multiple(v: boolean | string);
+    private _disabled;
+    get disabled(): boolean | string;
+    set disabled(v: boolean | string);
+    get isDisabled(): string | true | null;
+    private _required;
+    get required(): boolean | string;
+    set required(v: boolean | string);
+    inactiveColor: string;
+    inactiveType: string;
+    private _gap;
+    set gap(v: string | number);
+    get gapClass(): string;
+    get gap(): number;
+    buttons: QueryList<MatchaButtonComponent>;
+    constructor(elementRef: ElementRef);
+    ngAfterContentInit(): void;
+    private setButtonState;
+    private onButtonSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaButtonToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaButtonToggleComponent, "matcha-button-toggle", never, { "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "inactiveColor": { "alias": "inactiveColor"; "required": false; }; "inactiveType": { "alias": "inactiveType"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, ["buttons"], ["*"], false, never>;
+}
+
+declare class MatchaTabItemComponent {
+    title: string;
+    icon: string;
+    private _active;
+    set active(value: boolean | string);
+    get active(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTabItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaTabItemComponent, "matcha-tab", never, { "title": { "alias": "title"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaTabsComponent implements AfterContentInit {
+    tabs: QueryList<MatchaTabItemComponent>;
+    activeTabIndex: number;
+    tabSelected: EventEmitter<number>;
+    ngAfterContentInit(): void;
+    selectTab(tab: MatchaTabItemComponent): void;
+    selectTabByIndex(index: number): void;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaTabsComponent, "matcha-tabs", never, { "activeTabIndex": { "alias": "activeTabIndex"; "required": false; }; }, { "tabSelected": "tabSelected"; }, ["tabs"], ["*"], false, never>;
+}
+
+declare class MatchaDateComponent implements AfterContentInit, OnDestroy {
+    controls: QueryList<NgControl>;
+    private startDateControl;
+    private endDateControl;
+    private subscription;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Validação simples: data inicial não pode ser posterior à data final
+     */
+    private validateDateRange;
+    /**
+     * Remove um erro específico sem afetar outros erros
+     */
+    private removeSpecificError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDateComponent, "matcha-date", never, {}, {}, ["controls"], ["*"], false, never>;
+}
+
+declare class MatchaTimeComponent implements AfterContentInit, OnDestroy {
+    controls: QueryList<NgControl>;
+    startDateControlName?: string;
+    endDateControlName?: string;
+    allowCrossDays: boolean;
+    private startTimeControl;
+    private endTimeControl;
+    private startDateControl;
+    private endDateControl;
+    private subscription;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Validação de intervalo de tempo que pode cruzar dias
+     */
+    private validateTimeRange;
+    /**
+     * Define erros de validação nos controles
+     */
+    private setValidationErrors;
+    /**
+     * Remove erros específicos de validação
+     */
+    private clearValidationErrors;
+    /**
+     * Remove um erro específico sem afetar outros erros
+     */
+    private removeSpecificError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaTimeComponent, "matcha-time", never, { "startDateControlName": { "alias": "startDateControlName"; "required": false; }; "endDateControlName": { "alias": "endDateControlName"; "required": false; }; "allowCrossDays": { "alias": "allowCrossDays"; "required": false; }; }, {}, ["controls"], ["*"], false, never>;
+}
+
+declare class StepComponent {
+    step: any;
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepComponent, "matcha-step", never, { "step": { "alias": "title"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaStepperComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaStepperComponent, "matcha-stepper", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaStepperStateService {
+    steps$: BehaviorSubject<string[]>;
+    activeStep$: BehaviorSubject<number>;
+    setSteps(steps: string[]): void;
+    setActiveStep(index: number): void;
+    nextStep(): void;
+    prevStep(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaStepperStateService>;
+}
+
+declare class MatchaStepperContentComponent implements AfterContentInit {
+    private stepperState;
+    steps: QueryList<StepComponent>;
+    stepsArray: StepComponent[];
+    activeStep: number;
+    constructor(stepperState: MatchaStepperStateService);
+    ngAfterContentInit(): void;
+    nextStep(): void;
+    prevStep(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaStepperContentComponent, "matcha-stepper-content", never, {}, {}, ["steps"], never, false, never>;
+}
+
+declare class MatchaStepperControllerComponent implements OnInit {
+    private stepperState;
+    disableNext: boolean;
+    steps: string[];
+    activeStep: number;
+    constructor(stepperState: MatchaStepperStateService);
+    ngOnInit(): void;
+    goToStep(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperControllerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaStepperControllerComponent, "matcha-stepper-controller", never, { "disableNext": { "alias": "disableNext"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaDropListService {
+    private dropZones;
+    registerDropZone(element: HTMLElement, component: any): void;
+    unregisterDropZone(element: HTMLElement): void;
+    findDropZone(element: Element | null): any;
+    getAllDropZones(): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDropListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaDropListService>;
+}
+
+declare class MatchaDragDirective implements OnInit, OnDestroy {
+    elementRef: ElementRef<HTMLElement>;
+    private renderer;
+    private ngZone;
+    private dropListService;
+    matchaDragData: any;
+    matchaDragDisabled: boolean;
+    get dragItemClass(): boolean;
+    get dragDisabledClass(): boolean;
+    private listeners;
+    private isDragging;
+    private dragHandle?;
+    private dropList?;
+    private touchStartPosition;
+    private touchCurrentPosition;
+    private touchDragThreshold;
+    private isTouchDragging;
+    private dragPreview?;
+    private touchIdentifier?;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2, ngZone: NgZone, dropListService: MatchaDropListService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setDropList(dropList: any): void;
+    setDragHandle(handle: HTMLElement): void;
+    private setupDragEvents;
+    private onDragStart;
+    private onDragEnd;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private onTouchCancel;
+    private startTouchDrag;
+    private updateTouchDrag;
+    private endTouchDrag;
+    private cancelTouchDrag;
+    private createTouchDragPreview;
+    private checkDropZones;
+    private findDropZone;
+    private findAngularComponent;
+    private createFakeDragEvent;
+    private findTouch;
+    private resetTouchState;
+    private cleanupTouchDrag;
+    private createDragImage;
+    private cleanupListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaDragDirective, "[matchaDrag]", never, { "matchaDragData": { "alias": "matchaDragData"; "required": false; }; "matchaDragDisabled": { "alias": "matchaDragDisabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface MatchaDropListDroppedEvent<T = any> {
+    previousIndex: number;
+    currentIndex: number;
+    item: T;
+    container: MatchaDropListComponent;
+    previousContainer?: MatchaDropListComponent;
+    data: T[];
+}
+interface MatchaDropListConnectedToEvent<T = any> {
+    sourceData: T[];
+    targetData: T[];
+    item: T;
+    previousIndex: number;
+    currentIndex: number;
+}
+declare class MatchaDropListComponent<T = any> implements OnInit, OnDestroy, AfterContentInit {
+    elementRef: ElementRef<HTMLElement>;
+    private renderer;
+    private dropListService;
+    matchaDropListData: T[];
+    matchaDropListDisabled: boolean;
+    matchaDropListConnectedTo: MatchaDropListComponent[];
+    matchaDropListSortingDisabled: boolean;
+    matchaDropListAcceptPredicate?: (item: any, sourceContainer: MatchaDropListComponent, targetContainer: MatchaDropListComponent) => boolean;
+    matchaDropListDropped: EventEmitter<MatchaDropListDroppedEvent<T>>;
+    dragItems: QueryList<MatchaDragDirective>;
+    get dropListClass(): boolean;
+    private currentDragItem?;
+    private dragStartIndex;
+    private sourceContainer?;
+    isReceivingDrag: boolean;
+    showDropIndicator: boolean;
+    dropIndicatorPosition: number;
+    canAcceptDrop: boolean;
+    private calculatedDropIndex;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2, dropListService: MatchaDropListService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private setupDropZone;
+    private updateDropIndicator;
+    onDragStart(dragItem: MatchaDragDirective, event: DragEvent): void;
+    onDragEnd(): void;
+    private handleDrop;
+    private reorderItems;
+    private transferItem;
+    private getDragItemIndex;
+    notifyDragStart(dragItem: MatchaDragDirective, sourceContainer: MatchaDropListComponent): void;
+    notifyDragEnd(): void;
+    private canAcceptCurrentDrop;
+    handleTouchDragOver(event: any): void;
+    handleTouchDrop(event: any, dragItem: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDropListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDropListComponent<any>, "matcha-drop-list", never, { "matchaDropListData": { "alias": "matchaDropListData"; "required": false; }; "matchaDropListDisabled": { "alias": "matchaDropListDisabled"; "required": false; }; "matchaDropListConnectedTo": { "alias": "matchaDropListConnectedTo"; "required": false; }; "matchaDropListSortingDisabled": { "alias": "matchaDropListSortingDisabled"; "required": false; }; "matchaDropListAcceptPredicate": { "alias": "matchaDropListAcceptPredicate"; "required": false; }; }, { "matchaDropListDropped": "matchaDropListDropped"; }, ["dragItems"], ["*"], false, never>;
+}
+
+declare class MatchaPageLayoutComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPageLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaPageLayoutComponent, "matcha-page-layout", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaTooltipDirective {
+    private el;
+    private renderer;
+    tooltipText: string;
+    tooltipDisabled: boolean | string;
+    preferAbove: boolean;
+    preferBelow: boolean;
+    preferLeft: boolean;
+    preferRight: boolean;
+    tooltipEnableClose: boolean;
+    private tooltipElement;
+    private documentClickListener;
+    constructor(el: ElementRef, renderer: Renderer2);
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onClick(event: Event): void;
+    private createTooltip;
+    private destroyTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaTooltipDirective, "[matchaTooltip]", never, { "tooltipText": { "alias": "matchaTooltip"; "required": false; }; "tooltipDisabled": { "alias": "matchaTooltipDisabled"; "required": false; }; "preferAbove": { "alias": "matchaTooltipAbove"; "required": false; }; "preferBelow": { "alias": "matchaTooltipBelow"; "required": false; }; "preferLeft": { "alias": "matchaTooltipLeft"; "required": false; }; "preferRight": { "alias": "matchaTooltipRight"; "required": false; }; "tooltipEnableClose": { "alias": "matchaTooltipEnableClose"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaTooltipModule, [typeof MatchaTooltipDirective], [typeof i2.CommonModule], [typeof MatchaTooltipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaTooltipModule>;
+}
+
+declare class MatchaIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaIconModule, [typeof MatchaIconComponent], [typeof i2.CommonModule, typeof MatchaTooltipModule], [typeof MatchaIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaIconModule>;
+}
+
+declare class MatchaTitleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTitleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaTitleModule, [typeof MatchaTitleComponent], [typeof i2.CommonModule], [typeof MatchaTitleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaTitleModule>;
+}
+
+declare class MatchaDividerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDividerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDividerModule, [typeof MatchaDividerComponent], [typeof i2.CommonModule], [typeof MatchaDividerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDividerModule>;
+}
+
+declare class MatchaButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaButtonModule, [typeof MatchaButtonComponent], never, [typeof MatchaButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaButtonModule>;
+}
+
+declare class MatchaAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaAccordionModule, [typeof MatchaAccordionComponent, typeof MatchaAccordionItemComponent, typeof MatchaAccordionHeaderComponent, typeof MatchaAccordionContentComponent], [typeof i2.CommonModule, typeof MatchaIconModule, typeof MatchaTitleModule, typeof MatchaDividerModule, typeof MatchaTooltipModule, typeof MatchaButtonModule], [typeof MatchaAccordionComponent, typeof MatchaAccordionItemComponent, typeof MatchaAccordionHeaderComponent, typeof MatchaAccordionContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaAccordionModule>;
+}
+
+declare class MatchaInfiniteScrollModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaInfiniteScrollModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaInfiniteScrollModule, [typeof MatchaInfiniteScrollComponent, typeof MatchaInfiniteScrollDataComponent], [typeof i2.CommonModule], [typeof MatchaInfiniteScrollComponent, typeof MatchaInfiniteScrollDataComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaInfiniteScrollModule>;
+}
+
+declare class MatchaLazyloadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaLazyloadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaLazyloadModule, [typeof MatchaLazyloadComponent, typeof MatchaLazyloadDataComponent], [typeof i2.CommonModule], [typeof MatchaLazyloadComponent, typeof MatchaLazyloadDataComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaLazyloadModule>;
+}
+
+declare class MatchaElevationDirective {
+    private _elementRef;
+    private _renderer;
+    elevation: number | string;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaElevationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaElevationDirective, "[elevation]", never, { "elevation": { "alias": "elevation"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaElevationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaElevationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaElevationModule, [typeof MatchaElevationDirective], [typeof i2.CommonModule], [typeof MatchaElevationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaElevationModule>;
+}
+
+declare class MatchaModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaModalModule, [typeof MatchaModalHeaderComponent, typeof MatchaModalContentComponent, typeof MatchaModalFooterComponent, typeof MatchaModalOptionsComponent, typeof MatchaModalComponent], [typeof i2.CommonModule, typeof MatchaIconModule, typeof MatchaTitleModule, typeof MatchaDividerModule, typeof MatchaTooltipModule, typeof MatchaElevationModule], [typeof MatchaModalHeaderComponent, typeof MatchaModalContentComponent, typeof MatchaModalFooterComponent, typeof MatchaModalOptionsComponent, typeof MatchaModalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaModalModule>;
+}
+
+declare class MatchaCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaCardModule, [typeof MatchaCardComponent], [typeof i2.CommonModule, typeof MatchaElevationModule, typeof MatchaIconModule, typeof MatchaTitleModule, typeof MatchaDividerModule, typeof MatchaTooltipModule], [typeof MatchaCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaCardModule>;
+}
+
+declare class MatchaMasonryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaMasonryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaMasonryModule, [typeof MatchaMasonryComponent], [typeof i2.CommonModule], [typeof MatchaMasonryComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaMasonryModule>;
+}
+
+declare class MatchaButtonToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaButtonToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaButtonToggleModule, [typeof MatchaButtonToggleComponent], [typeof i2.CommonModule, typeof MatchaTooltipModule], [typeof MatchaButtonToggleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaButtonToggleModule>;
+}
+
+declare class MatchaToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaToolbarModule, [typeof MatchaToolbarComponent, typeof MatchaToolbarButtonComponent, typeof MatchaToolbarContentComponent, typeof MatchaToolbarMainButtonComponent, typeof MatchaToolbarCustomButtonComponent], [typeof i2.CommonModule, typeof MatchaButtonModule, typeof MatchaTitleModule, typeof MatchaTooltipModule], [typeof MatchaToolbarComponent, typeof MatchaToolbarButtonComponent, typeof MatchaToolbarContentComponent, typeof MatchaToolbarMainButtonComponent, typeof MatchaToolbarCustomButtonComponent, typeof MatchaTitleModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaToolbarModule>;
+}
+
+declare class MatchaGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaGridModule, [typeof MatchaGridComponent], [typeof i2.CommonModule], [typeof MatchaGridComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaGridModule>;
+}
+
+declare class MatchaFormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaFormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaFormFieldModule, [typeof MatchaFormFieldComponent, typeof MatchaLabelComponent, typeof MatchaErrorComponent], [typeof i2.CommonModule, typeof MatchaIconModule], [typeof MatchaFormFieldComponent, typeof MatchaLabelComponent, typeof MatchaErrorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaFormFieldModule>;
+}
+
+declare class MatchaOverflowDraggableComponent {
+    dragRef: string;
+    dragToScroll(): void;
+    get classes(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOverflowDraggableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaOverflowDraggableComponent, "matcha-overflow-draggable", never, { "dragRef": { "alias": "dragRef"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class MatchaOptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaOptionModule, [typeof MatchaOptionComponent], [typeof i2.CommonModule], [typeof MatchaOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaOptionModule>;
+}
+
+declare class MatchaAutocompleteDirective {
+    private ngControl;
+    private _elementRef;
+    private matchaOptionService;
+    matchaAutocomplete: MatchaAutocompleteComponent;
+    displayAutocomplete(): void;
+    hideAutocomplete(): void;
+    onArrowDown(event: KeyboardEvent): void;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLInputElement>, matchaOptionService: MatchaOptionService);
+    ngOnInit(): void;
+    private _updateInputValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaAutocompleteDirective, "[matchaAutocomplete]", never, { "matchaAutocomplete": { "alias": "matchaAutocomplete"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaAutocompleteModule, [typeof MatchaAutocompleteComponent, typeof MatchaAutocompleteDirective], [typeof i2.CommonModule, typeof i3.FormsModule, typeof MatchaOptionModule], [typeof MatchaAutocompleteComponent, typeof MatchaAutocompleteDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaAutocompleteModule>;
+}
+
+declare class MatchaBadgeDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaBadgeDirective, "[matcha-badge]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaBadgeModule, [typeof MatchaBadgeDirective], never, [typeof MatchaBadgeDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaBadgeModule>;
+}
+
+declare class MatchaRippleDirective implements OnDestroy {
+    private el;
+    rippleColor: string;
+    private ripples;
+    constructor(el: ElementRef);
+    onMouseDown(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRippleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaRippleDirective, "[matchaRipple]", never, { "rippleColor": { "alias": "rippleColor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaRippleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRippleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaRippleModule, [typeof MatchaRippleDirective], [typeof i2.CommonModule], [typeof MatchaRippleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaRippleModule>;
+}
+
+declare class MatchaCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaCheckboxModule, [typeof MatchaCheckboxComponent], [typeof i2.CommonModule, typeof MatchaRippleModule], [typeof MatchaCheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaCheckboxModule>;
+}
+
+declare class MatchaChipsDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaChipsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaChipsDirective, "[matchaChips]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaChipsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaChipsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaChipsModule, [typeof MatchaChipsDirective], never, [typeof MatchaChipsDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaChipsModule>;
+}
+
+declare class MatchaDatepickerDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDatepickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaDatepickerDirective, "[matcha-datepicker]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaDatepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDatepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDatepickerModule, [typeof MatchaDatepickerDirective], never, [typeof MatchaDatepickerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDatepickerModule>;
+}
+
+declare class MatchaHintTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaHintTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaHintTextModule, [typeof MatchaHintTextComponent], [typeof i2.CommonModule, typeof MatchaIconModule], [typeof MatchaHintTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaHintTextModule>;
+}
+
+declare class MatchaInputDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaInputDirective, "[matcha-input]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaInputModule, [typeof MatchaInputDirective], never, [typeof MatchaInputDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaInputModule>;
+}
+
+declare class MatchaMenuTriggerForDirective {
+    private _elementRef;
+    private _renderer;
+    menu: MatchaMenuComponent;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    onClick(event: Event): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaMenuTriggerForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaMenuTriggerForDirective, "[matchaMenuTriggerFor]", ["matchaMenuTriggerFor"], { "menu": { "alias": "matchaMenuTriggerFor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaMenuModule, [typeof MatchaMenuComponent, typeof MatchaMenuTriggerForDirective], [typeof i2.CommonModule], [typeof MatchaMenuComponent, typeof MatchaMenuTriggerForDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaMenuModule>;
+}
+
+declare class MatchaPaginatorDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPaginatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaPaginatorDirective, "[matchaPaginator]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaPaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaPaginatorModule, [typeof MatchaPaginatorDirective], [typeof i2.CommonModule], [typeof MatchaPaginatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaPaginatorModule>;
+}
+
+declare class MatchaProgressBarDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaProgressBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaProgressBarDirective, "[matcha-progress-bar]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaProgressBarModule, [typeof MatchaProgressBarDirective], [typeof i2.CommonModule], [typeof MatchaProgressBarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaProgressBarModule>;
+}
+
+declare class MatchaRadioButtonDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRadioButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaRadioButtonDirective, "[matchaRadioButton]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaRadioButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRadioButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaRadioButtonModule, [typeof MatchaRadioButtonDirective], [typeof i2.CommonModule], [typeof MatchaRadioButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaRadioButtonModule>;
+}
+
+declare class MatchaSelectDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSelectDirective, "[matcha-select]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSelectModule, [typeof MatchaSelectDirective], [typeof i2.CommonModule], [typeof MatchaSelectDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSelectModule>;
+}
+
+declare class MatchaSidenavDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSidenavDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSidenavDirective, "[matcha-sidenav]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaSidenavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSidenavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSidenavModule, [typeof MatchaSidenavDirective], [typeof i2.CommonModule], [typeof MatchaSidenavDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSidenavModule>;
+}
+
+declare class MatchaSlideToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSlideToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSlideToggleModule, [typeof MatchaSlideToggleComponent], [typeof i2.CommonModule, typeof i3.FormsModule], [typeof MatchaSlideToggleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSlideToggleModule>;
+}
+
+declare class MatchaSliderDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSliderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSliderDirective, "[matchaSlider]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSliderModule, [typeof MatchaSliderDirective], [typeof i2.CommonModule], [typeof MatchaSliderDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSliderModule>;
+}
+
+declare class MatchaSnackBarDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSnackBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSnackBarDirective, "[matchaSnackBar]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaSnackBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSnackBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSnackBarModule, [typeof MatchaSnackBarDirective], [typeof i2.CommonModule], [typeof MatchaSnackBarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSnackBarModule>;
+}
+
+declare class MatchaSortHeaderDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSortHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSortHeaderDirective, "[matchaSortHeader]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaSortHeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSortHeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSortHeaderModule, [typeof MatchaSortHeaderDirective], [typeof i2.CommonModule], [typeof MatchaSortHeaderDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSortHeaderModule>;
+}
+
+declare class MatchaSpinModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSpinModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSpinModule, [typeof MatchaSpinComponent], [typeof i2.CommonModule], [typeof MatchaSpinComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSpinModule>;
+}
+
+declare class MatchaSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSpinnerModule, [typeof MatchaSpinnerComponent], [typeof i2.CommonModule], [typeof MatchaSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSpinnerModule>;
+}
+
+declare class PrevStepDirective {
+    private stepper;
+    constructor(stepper: MatchaStepperContentComponent | null);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrevStepDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PrevStepDirective, "[prevStep]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NextStepDirective {
+    private stepper;
+    constructor(stepper: MatchaStepperContentComponent | null);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NextStepDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NextStepDirective, "[nextStep]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MatchaStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaStepperModule, [typeof MatchaStepperControllerComponent, typeof MatchaStepperComponent, typeof MatchaStepperContentComponent, typeof StepComponent], [typeof i2.CommonModule, typeof PrevStepDirective, typeof NextStepDirective], [typeof MatchaStepperControllerComponent, typeof MatchaStepperComponent, typeof MatchaStepperContentComponent, typeof StepComponent, typeof PrevStepDirective, typeof NextStepDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaStepperModule>;
+}
+
+declare class MatchaTableDirective {
+    private _elementRef;
+    private _renderer;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaTableDirective, "[matchaTable]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaTableModule, [typeof MatchaTableDirective], [typeof i2.CommonModule], [typeof MatchaTableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaTableModule>;
+}
+
+declare class MatchaTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaTabsModule, [typeof MatchaTabsComponent, typeof MatchaTabItemComponent], [typeof i2.CommonModule, typeof MatchaTooltipModule, typeof MatchaIconModule], [typeof MatchaTabsComponent, typeof MatchaTabItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaTabsModule>;
+}
+
+declare class MatchaDateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDateModule, [typeof MatchaDateComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule], [typeof MatchaDateComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDateModule>;
+}
+
+declare class MatchaTimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaTimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaTimeModule, [typeof MatchaTimeComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule], [typeof MatchaTimeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaTimeModule>;
+}
+
+declare class MatchaDragHandleDirective implements OnInit {
+    private elementRef;
+    private dragDirective;
+    get dragHandleClass(): boolean;
+    constructor(elementRef: ElementRef<HTMLElement>, dragDirective: MatchaDragDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDragHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaDragHandleDirective, "[matchaDragHandle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MatchaDropListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDropListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDropListModule, [typeof MatchaDropListComponent, typeof MatchaDragDirective, typeof MatchaDragHandleDirective], [typeof i2.CommonModule], [typeof MatchaDropListComponent, typeof MatchaDragDirective, typeof MatchaDragHandleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDropListModule>;
+}
+
+declare class MatchaPageLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPageLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaPageLayoutModule, [typeof MatchaPageLayoutComponent], [typeof i2.CommonModule, typeof MatchaStepperModule], [typeof MatchaPageLayoutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaPageLayoutModule>;
+}
+
+declare class MatchaComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaComponentsModule, [typeof MatchaOverflowDraggableComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof MatchaAccordionModule, typeof MatchaOptionModule, typeof MatchaAutocompleteModule, typeof MatchaBadgeModule, typeof MatchaButtonModule, typeof MatchaButtonToggleModule, typeof MatchaCardModule, typeof MatchaCheckboxModule, typeof MatchaChipsModule, typeof MatchaDatepickerModule, typeof MatchaDividerModule, typeof MatchaElevationModule, typeof MatchaFormFieldModule, typeof MatchaHintTextModule, typeof MatchaIconModule, typeof MatchaInfiniteScrollModule, typeof MatchaLazyloadModule, typeof MatchaInputModule, typeof MatchaMasonryModule, typeof MatchaMenuModule, typeof MatchaModalModule, typeof MatchaPaginatorModule, typeof MatchaProgressBarModule, typeof MatchaRadioButtonModule, typeof MatchaRippleModule, typeof MatchaSelectModule, typeof MatchaSidenavModule, typeof MatchaSlideToggleModule, typeof MatchaSliderModule, typeof MatchaSnackBarModule, typeof MatchaSortHeaderModule, typeof MatchaSpinModule, typeof MatchaSpinnerModule, typeof MatchaStepperModule, typeof MatchaTableModule, typeof MatchaTabsModule, typeof MatchaTitleModule, typeof MatchaTooltipModule, typeof MatchaDateModule, typeof MatchaTimeModule, typeof MatchaDropListModule, typeof MatchaPageLayoutModule], [typeof MatchaAccordionModule, typeof MatchaAutocompleteModule, typeof MatchaBadgeModule, typeof MatchaButtonModule, typeof MatchaButtonToggleModule, typeof MatchaCardModule, typeof MatchaCheckboxModule, typeof MatchaChipsModule, typeof MatchaDatepickerModule, typeof MatchaDividerModule, typeof MatchaElevationModule, typeof MatchaFormFieldModule, typeof MatchaHintTextModule, typeof MatchaIconModule, typeof MatchaInfiniteScrollModule, typeof MatchaLazyloadModule, typeof MatchaInputModule, typeof MatchaMasonryModule, typeof MatchaMenuModule, typeof MatchaModalModule, typeof MatchaOptionModule, typeof MatchaPaginatorModule, typeof MatchaProgressBarModule, typeof MatchaRadioButtonModule, typeof MatchaRippleModule, typeof MatchaSelectModule, typeof MatchaSidenavModule, typeof MatchaSlideToggleModule, typeof MatchaSliderModule, typeof MatchaSnackBarModule, typeof MatchaSortHeaderModule, typeof MatchaSpinModule, typeof MatchaSpinnerModule, typeof MatchaStepperModule, typeof MatchaTableModule, typeof MatchaTabsModule, typeof MatchaTitleModule, typeof MatchaTooltipModule, typeof MatchaDateModule, typeof MatchaTimeModule, typeof MatchaDropListModule, typeof MatchaPageLayoutModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaComponentsModule>;
+}
+
+declare class MatchaSkeletonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSkeletonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSkeletonModule, [typeof MatchaSkeletonComponent], [typeof i2.CommonModule], [typeof MatchaSkeletonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSkeletonModule>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Serviço responsável pela implementação técnica do overlay e backdrop dos modais.
+ *
+ * Este serviço lida com a criação e gerenciamento do container do overlay,
+ * criação do backdrop e manipulação do DOM. É um serviço de baixo nível
+ * utilizado internamente pelo MatchaModalService.
+ *
+ * @example
+ * ```typescript
+ * constructor(private overlayService: MatchaOverlayService) {}
+ *
+ * createOverlay() {
+ *   this.overlayService.open(MyComponent);
+ * }
+ * ```
  */
-/// <amd-module name="matcha-components" />
-export * from './public-api';
+declare class MatchaOverlayService {
+    private appRef;
+    private injector;
+    private rendererFactory;
+    private overlayContainer;
+    private activeModal;
+    private backdrop;
+    private renderer;
+    constructor(appRef: ApplicationRef, injector: Injector, rendererFactory: RendererFactory2);
+    /**
+     * Cria o container do overlay se ainda não existir.
+     * O container é um elemento div que será usado para hospedar os modais.
+     *
+     * @private
+     */
+    private createOverlayContainer;
+    /**
+     * Remove o container do overlay do DOM.
+     *
+     * @private
+     */
+    private removeOverlayContainer;
+    /**
+     * Cria o backdrop do modal se ainda não existir.
+     * O backdrop é um elemento div que cria o efeito de escurecimento
+     * por trás do modal.
+     *
+     * @private
+     */
+    private createBackdrop;
+    /**
+     * Remove o backdrop do modal do DOM.
+     *
+     * @private
+     */
+    private removeBackdrop;
+    /**
+     * Abre um componente dentro de um modal.
+     *
+     * @param component - O componente que será exibido dentro do modal
+     * @param config - Configurações opcionais para o modal
+     * @returns Uma referência ao componente criado
+     *
+     * @example
+     * ```typescript
+     * const componentRef = this.overlayService.open(MyComponent, {
+     *   data: { id: 1 }
+     * });
+     * ```
+     */
+    open<T>(component: Type<T>, config?: any): ComponentRef<T>;
+    /**
+     * Fecha o modal atualmente aberto e remove o backdrop e o container.
+     *
+     * @example
+     * ```typescript
+     * this.overlayService.close();
+     * ```
+     */
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaOverlayService>;
+}
+
+interface ModalComponent {
+    afterClose?: Observable<any>;
+    data?: any;
+}
+declare class MatchaModalService {
+    private overlayService;
+    private afterCloseSubject;
+    private currentData;
+    constructor(overlayService: MatchaOverlayService);
+    open<T extends ModalComponent>(component: Type<T>, data?: any): {
+        componentRef: i0.ComponentRef<T>;
+        afterClose: Observable<any>;
+    };
+    close(result?: any): void;
+    getData(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaModalService>;
+}
+
+declare class StepContentDirective {
+    template: TemplateRef<any>;
+    step: string;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepContentDirective, "[step]", never, { "step": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { MatchaAccordionComponent, MatchaAccordionContentComponent, MatchaAccordionHeaderComponent, MatchaAccordionItemComponent, MatchaAccordionModule, MatchaAutocompleteComponent, MatchaAutocompleteDirective, MatchaAutocompleteModule, MatchaBadgeDirective, MatchaBadgeModule, MatchaButtonComponent, MatchaButtonModule, MatchaButtonToggleComponent, MatchaButtonToggleModule, MatchaCardComponent, MatchaCardModule, MatchaCheckboxComponent, MatchaCheckboxModule, MatchaChipsDirective, MatchaChipsModule, MatchaComponentsModule, MatchaDateComponent, MatchaDateModule, MatchaDatepickerDirective, MatchaDatepickerModule, MatchaDividerComponent, MatchaDividerModule, MatchaDragDirective, MatchaDragHandleDirective, MatchaDropListComponent, MatchaDropListModule, MatchaElevationDirective, MatchaElevationModule, MatchaErrorComponent, MatchaFormFieldComponent, MatchaFormFieldModule, MatchaGridComponent, MatchaGridModule, MatchaHintTextComponent, MatchaHintTextModule, MatchaIconComponent, MatchaIconModule, MatchaInfiniteScrollComponent, MatchaInfiniteScrollDataComponent, MatchaInfiniteScrollModule, MatchaInputDirective, MatchaInputModule, MatchaLabelComponent, MatchaLazyloadComponent, MatchaLazyloadDataComponent, MatchaLazyloadModule, MatchaMasonryComponent, MatchaMasonryModule, MatchaMenuComponent, MatchaMenuModule, MatchaMenuTriggerForDirective, MatchaModalComponent, MatchaModalContentComponent, MatchaModalFooterComponent, MatchaModalHeaderComponent, MatchaModalModule, MatchaModalOptionsComponent, MatchaModalService, MatchaOptionComponent, MatchaOptionModule, MatchaOptionService, MatchaOverlayService, MatchaPageLayoutComponent, MatchaPageLayoutModule, MatchaPaginatorDirective, MatchaPaginatorModule, MatchaProgressBarDirective, MatchaProgressBarModule, MatchaRadioButtonDirective, MatchaRadioButtonModule, MatchaRippleDirective, MatchaRippleModule, MatchaSelectDirective, MatchaSelectModule, MatchaSidenavDirective, MatchaSidenavModule, MatchaSkeletonComponent, MatchaSkeletonModule, MatchaSlideToggleComponent, MatchaSlideToggleModule, MatchaSliderDirective, MatchaSliderModule, MatchaSnackBarDirective, MatchaSnackBarModule, MatchaSortHeaderDirective, MatchaSortHeaderModule, MatchaSpinComponent, MatchaSpinModule, MatchaSpinnerComponent, MatchaSpinnerModule, MatchaStepperComponent, MatchaStepperContentComponent, MatchaStepperControllerComponent, MatchaStepperModule, MatchaStepperStateService, MatchaTabItemComponent, MatchaTableDirective, MatchaTableModule, MatchaTabsComponent, MatchaTabsModule, MatchaTimeComponent, MatchaTimeModule, MatchaTitleComponent, MatchaTitleModule, MatchaToolbarButtonComponent, MatchaToolbarComponent, MatchaToolbarContentComponent, MatchaToolbarCustomButtonComponent, MatchaToolbarMainButtonComponent, MatchaToolbarModule, MatchaTooltipDirective, MatchaTooltipModule, NextStepDirective, PrevStepDirective, StepComponent, StepContentDirective };
+export type { ILevelClasses, MatchaDropListConnectedToEvent, MatchaDropListDroppedEvent, ModalComponent };