matcha-components 20.15.0 → 20.17.0

package/index.d.ts

@@ -0,0 +1,2030 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, EventEmitter, SimpleChanges, AfterContentInit, OnDestroy, QueryList, ElementRef, Renderer2, TemplateRef, ChangeDetectorRef, AfterViewInit, NgZone, ApplicationRef, Injector, RendererFactory2, Type, ComponentRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as i3 from '@angular/forms';
+import { FormControlName, ControlValueAccessor, NgControl } from '@angular/forms';
+import { HttpClient } from '@angular/common/http';
+import * as i2 from '@angular/common';
+
+/**
+ * Interface que deve ser implementada por componentes que querem usar matcha-option como filho
+ *
+ * Permite que matcha-option seja usado em diferentes contextos:
+ * - matcha-autocomplete
+ * - matcha-select
+ * - matcha-menu
+ * - etc.
+ */
+interface MatchaOptionParent {
+    /**
+     * Método chamado quando uma opção é selecionada
+     * @param option - A instância do MatchaOptionComponent selecionado
+     */
+    selectOption(option: any): void;
+}
+/**
+ * Token de injeção para MatchaOptionParent
+ * Usado para injetar o componente pai no matcha-option
+ */
+declare const MATCHA_OPTION_PARENT: unique symbol;
+
+declare class MatchaAccordionItemComponent implements OnInit, OnChanges {
+    private _stretch;
+    private _isOpen;
+    set stretch(value: boolean | string);
+    get stretch(): boolean;
+    get stretchClass(): boolean;
+    private _clickableHeader;
+    set clickableHeader(value: boolean | string);
+    get clickableHeader(): boolean;
+    set isOpen(value: boolean | string);
+    get isOpen(): boolean;
+    get isOpenClass(): boolean;
+    opened: EventEmitter<boolean>;
+    toggleRequested: EventEmitter<void>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    toggleAccordion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAccordionItemComponent, "matcha-accordion-item", never, { "stretch": { "alias": "stretch"; "required": false; }; "clickableHeader": { "alias": "clickableHeader"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "opened": "opened"; "toggleRequested": "toggleRequested"; }, never, ["matcha-accordion-header", "matcha-accordion-content", "*"], false, never>;
+}
+
+declare class MatchaAccordionComponent implements AfterContentInit, OnDestroy {
+    private _multiple;
+    set multiple(value: boolean | string);
+    get multiple(): boolean;
+    openedChange: EventEmitter<boolean>;
+    items: QueryList<MatchaAccordionItemComponent>;
+    private subscriptions;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private setupItems;
+    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);
+    get alphaAttr(): string | null;
+    private _tint;
+    get tint(): boolean | string;
+    set tint(v: boolean | string);
+    get tintAttr(): string | null;
+    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>;
+}
+
+interface BreakpointState {
+    matches: boolean;
+    breakpoint: string;
+}
+/**
+ * Serviço singleton para observação de breakpoints CSS
+ * Funciona tanto no browser quanto no servidor (SSR)
+ */
+declare class MatchaBreakpointObserver implements OnDestroy {
+    private platformId;
+    private breakpointSubject;
+    private resizeSubscription;
+    private isBrowser;
+    private currentBreakpoints;
+    constructor(platformId: Object);
+    ngOnDestroy(): void;
+    /**
+     * Observa um breakpoint específico
+     * @param breakpoint - String no formato CSS media query (ex: '(max-width: 768px)')
+     * @returns Observable<BreakpointState>
+     */
+    observe(breakpoint: string): Observable<BreakpointState>;
+    /**
+     * Verifica se um breakpoint específico está ativo
+     * @param breakpoint - String no formato CSS media query
+     * @returns boolean
+     */
+    isMatched(breakpoint: string): boolean;
+    /**
+     * Obtém o estado atual do breakpoint
+     * @param breakpoint - String no formato CSS media query
+     * @returns BreakpointState
+     */
+    getState(breakpoint: string): BreakpointState;
+    /**
+     * Observa múltiplos breakpoints simultaneamente
+     * @param breakpoints - Array de strings de breakpoints
+     * @returns Observable<Map<string, boolean>>
+     */
+    observeMultiple(breakpoints: string[]): Observable<Map<string, boolean>>;
+    private setupResizeListener;
+    private checkBreakpoint;
+    /**
+     * Método utilitário para criar breakpoints comuns
+     */
+    static createBreakpoint(width: number, condition?: 'max' | 'min'): string;
+    /**
+     * Breakpoints pré-definidos para facilitar o uso
+     */
+    static readonly BREAKPOINTS: {
+        readonly XS: "(max-width: 480px)";
+        readonly SM: "(max-width: 768px)";
+        readonly MD: "(max-width: 1024px)";
+        readonly LG: "(max-width: 1200px)";
+        readonly XL: "(max-width: 1440px)";
+        readonly MOBILE: "(max-width: 768px)";
+        readonly TABLET: "(min-width: 769px) and (max-width: 1024px)";
+        readonly DESKTOP: "(min-width: 1025px)";
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaBreakpointObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaBreakpointObserver>;
+}
+
+interface DrawerItem {
+    id: string;
+    label: string;
+    icon?: string;
+    route?: string;
+    action?: () => void;
+    badge?: string | number;
+    disabled?: boolean;
+    divider?: boolean;
+}
+interface DrawerSection {
+    id: string;
+    title?: string;
+    items: DrawerItem[];
+    position: 'top' | 'bottom';
+    divider?: boolean;
+}
+type DrawerMode = 'push' | 'overlay';
+type DrawerPosition = 'left' | 'right';
+declare class MatchaDrawerComponent implements OnInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    private cdr;
+    private breakpointObserver;
+    isOpen: boolean;
+    mode: DrawerMode;
+    position: DrawerPosition;
+    width: string;
+    hasBackdrop: boolean;
+    disableClose: boolean;
+    autoCloseOnMobile: boolean;
+    breakpoint: number;
+    elevation: number;
+    hasFooter: boolean;
+    responsiveMode: boolean;
+    mobileMode: DrawerMode;
+    desktopMode: DrawerMode;
+    mobileBreakpoint: number;
+    autoResponsive: boolean;
+    isOpenChange: EventEmitter<boolean>;
+    drawerToggle: EventEmitter<void>;
+    drawerOpened: EventEmitter<void>;
+    drawerClosed: EventEmitter<void>;
+    drawerContent: TemplateRef<any>;
+    get drawerClasses(): string;
+    get drawerWidth(): string;
+    get drawerHeight(): string;
+    private resizeObserver;
+    private isMobile;
+    private bodyScrollLocked;
+    private breakpointSubscription?;
+    private currentResponsiveMode;
+    private resizeSubject;
+    constructor(elementRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, breakpointObserver: MatchaBreakpointObserver);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupResizeObserver;
+    private setupResizeDebounce;
+    private checkScreenSize;
+    private setupResponsiveMode;
+    private updateModeBasedOnScreen;
+    private updateDrawerStateOnResize;
+    private setupSmartInitialState;
+    private setupBodyScrollLock;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    onBackdropClick(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    getDrawerTransform(): string;
+    get animationState(): "open" | "closed";
+    get isOverlayMode(): boolean;
+    get isPushMode(): boolean;
+    get currentMode(): DrawerMode;
+    get isMobileView(): boolean;
+    get isResponsiveActive(): boolean;
+    get isAutoResponsiveActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDrawerComponent, "matcha-drawer", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "position": { "alias": "position"; "required": false; }; "width": { "alias": "width"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "disableClose": { "alias": "disableClose"; "required": false; }; "autoCloseOnMobile": { "alias": "autoCloseOnMobile"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "elevation": { "alias": "elevation"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "responsiveMode": { "alias": "responsiveMode"; "required": false; }; "mobileMode": { "alias": "mobileMode"; "required": false; }; "desktopMode": { "alias": "desktopMode"; "required": false; }; "mobileBreakpoint": { "alias": "mobileBreakpoint"; "required": false; }; "autoResponsive": { "alias": "autoResponsive"; "required": false; }; }, { "isOpenChange": "isOpenChange"; "drawerToggle": "drawerToggle"; "drawerOpened": "drawerOpened"; "drawerClosed": "drawerClosed"; }, never, ["[drawer-header]", "[drawer-content]", "*", "[drawer-footer]"], false, never>;
+}
+
+declare class MatchaDrawerContainerComponent implements OnInit, OnDestroy {
+    hasBackdrop: boolean;
+    autoFocus: boolean;
+    drawer: MatchaDrawerComponent;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupDrawerEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDrawerContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDrawerContainerComponent, "matcha-drawer-container", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, ["drawer"], ["*"], false, never>;
+}
+
+declare class MatchaDrawerContentComponent {
+    padding: string;
+    scrollable: boolean;
+    maxHeight: string;
+    get contentClasses(): string;
+    get maxHeightStyle(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDrawerContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDrawerContentComponent, "matcha-drawer-content", never, { "padding": { "alias": "padding"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, 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 {
+    elevation: number;
+    isMobileScreen: boolean;
+    get elevationClass(): string;
+    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, { "elevation": { "alias": "elevation"; "required": false; }; }, {}, 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 | undefined | 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+    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", "matcha-hint-text"], 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;
+    get disabled(): boolean;
+    set disabled(value: boolean | string);
+    private _checked;
+    get checked(): boolean;
+    set checked(value: boolean | string);
+    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 MatchaRadioComponent implements ControlValueAccessor {
+    color: string;
+    value: any;
+    name: string;
+    private _disabled;
+    set disabled(value: boolean | string);
+    get disabled(): boolean;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    private _modelValue;
+    checkedChange: EventEmitter<{
+        checked: boolean;
+    }>;
+    change: EventEmitter<Event>;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaRadioComponent, "matcha-radio", never, { "color": { "alias": "color"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "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 _progressValue;
+    set progress(value: string | number);
+    get progress(): string | number;
+    get _progress(): string | number;
+    color: string;
+    get _color(): string;
+    size: string | null;
+    get hostSize(): 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: string;
+    size: string;
+    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;
+    get amountArray(): number[];
+    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 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 MatchaDateRangeComponent implements AfterContentInit, OnDestroy {
+    controls: QueryList<NgControl>;
+    private startDateControl;
+    private endDateControl;
+    private subscription;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Validação de formato de data e intervalo: 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<MatchaDateRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaDateRangeComponent, "matcha-date-range", 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 MatchaStepperStateService {
+    private steps;
+    private _steps$;
+    steps$: rxjs.Observable<any[]>;
+    private _activeStep$;
+    activeStep$: rxjs.Observable<number>;
+    private pendingActiveStep;
+    setSteps(steps: any[]): void;
+    setActiveStep(index: number): void;
+    nextStep(): void;
+    prevStep(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaStepperStateService>;
+}
+
+declare class MatchaStepperComponent {
+    private stepperState;
+    active: number;
+    constructor(stepperState: MatchaStepperStateService);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaStepperComponent, "matcha-stepper", never, { "active": { "alias": "active"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+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 MatchaAvatarComponent {
+    src: string;
+    name: string;
+    size: 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+    color: string;
+    private _disabled;
+    set disabled(value: boolean | string);
+    get disabled(): boolean;
+    get initials(): string;
+    get hasImage(): boolean;
+    get hasName(): boolean;
+    get showDefaultIcon(): boolean;
+    get sizeClass(): string;
+    get avatarClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAvatarComponent, "matcha-avatar", never, { "src": { "alias": "src"; "required": false; }; "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaOptionComponent {
+    private parent;
+    private elRef;
+    value: any;
+    disabled: boolean;
+    selected: boolean;
+    optionClick: EventEmitter<any>;
+    optionSelect: EventEmitter<MatchaOptionComponent>;
+    constructor(parent: MatchaOptionParent | null, elRef: ElementRef);
+    onClick(): void;
+    private findParentAndSelect;
+    onKeydown(ev: KeyboardEvent): void;
+    get nativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaOptionComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaOptionComponent, "matcha-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "optionClick": "optionClick"; "optionSelect": "optionSelect"; }, never, ["*"], false, never>;
+}
+
+interface PanelPosition {
+    top: number;
+    left: number;
+    width: number;
+    maxHeight?: number;
+}
+type PanelPlacement = 'bottom' | 'top' | 'auto';
+declare class MatchaPanelComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
+    private elRef;
+    private cdr;
+    placement: PanelPlacement;
+    maxHeight: number;
+    minWidth: number;
+    offset: number;
+    triggerElement?: HTMLElement;
+    open: boolean;
+    opened: EventEmitter<void>;
+    closed: EventEmitter<void>;
+    panelRef?: ElementRef<HTMLElement>;
+    panelStyle: {
+        [key: string]: any;
+    };
+    private destroy$;
+    private scrollListener?;
+    private resizeListener?;
+    constructor(elRef: ElementRef, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Anexa o painel a um elemento trigger
+     */
+    attachTo(trigger: HTMLElement): void;
+    ngAfterViewInit(): void;
+    /**
+     * Lifecycle hook para detectar mudanças no triggerElement
+     */
+    ngOnChanges(): void;
+    /**
+     * Abre o painel
+     */
+    openPanel(): void;
+    /**
+     * Fecha o painel
+     */
+    closePanel(): void;
+    /**
+     * Alterna o estado do painel
+     */
+    togglePanel(): void;
+    /**
+     * Atualiza a posição do painel (simplificado para absolute)
+     */
+    updatePosition(): void;
+    /**
+     * Calcula a posição ideal do painel (simplificado para absolute)
+     */
+    private calculatePosition;
+    /**
+     * Configura listeners para scroll e resize
+     */
+    private setupListeners;
+    /**
+     * Remove listeners
+     */
+    private cleanupListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaPanelComponent, "matcha-panel", never, { "placement": { "alias": "placement"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "triggerElement": { "alias": "triggerElement"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["*"], false, never>;
+}
+
+declare class MatchaAutocompleteComponent implements AfterContentInit, AfterViewInit, MatchaOptionParent {
+    elRef: ElementRef;
+    private renderer;
+    private cdr;
+    options: QueryList<MatchaOptionComponent>;
+    panel: MatchaPanelComponent;
+    private selectedValue;
+    placement: 'bottom' | 'top' | 'auto';
+    maxHeight: number;
+    minWidth: number;
+    opened: EventEmitter<void>;
+    closed: EventEmitter<void>;
+    open: boolean;
+    triggerElement?: HTMLElement;
+    private activeIndex;
+    constructor(elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    attachTo(input: HTMLElement): void;
+    private closeOtherPanels;
+    private notifyDirectiveOfSelection;
+    openPanel(): void;
+    closePanel(): void;
+    togglePanel(): void;
+    resetActive(): void;
+    private updateSelectedStates;
+    highlightNext(): void;
+    highlightPrevious(): void;
+    private scrollToActive;
+    selectActive(): void;
+    selectOption(option: MatchaOptionComponent): void;
+    getSelectedValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaAutocompleteComponent, "matcha-autocomplete", never, { "placement": { "alias": "placement"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, ["options"], ["*"], false, never>;
+}
+
+declare class MatchaSelectComponent implements AfterContentInit, AfterViewInit, MatchaOptionParent, ControlValueAccessor {
+    elRef: ElementRef;
+    private renderer;
+    private cdr;
+    options: QueryList<MatchaOptionComponent>;
+    panel: MatchaPanelComponent;
+    selectedValue: any;
+    placement: 'bottom' | 'top' | 'auto';
+    maxHeight: number;
+    minWidth: number;
+    placeholder: string;
+    disabled: boolean;
+    opened: EventEmitter<void>;
+    closed: EventEmitter<void>;
+    selectionChange: EventEmitter<any>;
+    open: boolean;
+    triggerElement?: HTMLElement;
+    private activeIndex;
+    private onChange;
+    private onTouched;
+    isDisabled: boolean;
+    constructor(elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    private setupKeyboardNavigation;
+    private handleArrowDown;
+    private handleArrowUp;
+    private handleEnterOrSpace;
+    private handleEscape;
+    private closeOtherPanels;
+    private notifyDirectiveOfSelection;
+    onTriggerClick(): void;
+    openPanel(): void;
+    closePanel(): void;
+    togglePanel(): void;
+    resetActive(): void;
+    private setActiveIndexFromSelectedValue;
+    private selectNextOption;
+    private selectPreviousOption;
+    private selectOptionByIndex;
+    private updateSelectedStates;
+    highlightNext(): void;
+    highlightPrevious(): void;
+    private scrollToActive;
+    selectActive(): void;
+    selectOption(option: MatchaOptionComponent): void;
+    getSelectedValue(): any;
+    setValue(value: any): void;
+    clearSelection(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaSelectComponent, "matcha-select", never, { "placement": { "alias": "placement"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; "selectionChange": "selectionChange"; }, ["options"], ["*"], false, never>;
+}
+
+interface PageEvent {
+    /** The current page index. */
+    pageIndex: number;
+    /** Index of the page that was selected previously. */
+    previousPageIndex?: number;
+    /** The current page size. */
+    pageSize: number;
+    /** The current total number of items being paged. */
+    length: number;
+}
+
+/**
+ * Service to internationalize the paginator component.
+ * Based on Angular Material's MatPaginatorIntl
+ */
+declare class MatchaPaginatorIntl {
+    /** Stream to emit from when labels are changed. Used by the paginator to update the labels. */
+    readonly changes: Subject<void>;
+    /** A label for the page size selector. */
+    itemsPerPageLabel: string;
+    /** A label for the button that increments the current page. */
+    nextPageLabel: string;
+    /** A label for the button that decrements the current page. */
+    previousPageLabel: string;
+    /** A label for the button that moves to the first page. */
+    firstPageLabel: string;
+    /** A label for the button that moves to the last page. */
+    lastPageLabel: string;
+    /**
+     * A label for the range of items within the current page and the length of the whole list.
+     */
+    getRangeLabel: (page: number, pageSize: number, length: number) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPaginatorIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchaPaginatorIntl>;
+}
+
+declare class MatchaPaginatorComponent implements OnDestroy {
+    _intl: MatchaPaginatorIntl;
+    private _changeDetectorRef;
+    pageIndex: number;
+    length: number;
+    pageSize: number;
+    pageSizeOptions: number[];
+    /** Color theme for active page button. Defaults to 'accent' */
+    color: string;
+    page: EventEmitter<PageEvent>;
+    private _intlChanges;
+    constructor(_intl: MatchaPaginatorIntl, _changeDetectorRef: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    get currentPage(): number;
+    get totalPages(): number;
+    get hasPreviousPage(): boolean;
+    get hasNextPage(): boolean;
+    get displayPages(): (number | string)[];
+    trackByPage(index: number, item: number | string): number | string;
+    /** Check if item is a number (for template use only) */
+    isNumber(value: any): boolean;
+    /** Navigate to previous page */
+    previousPage(): void;
+    /** Navigate to next page */
+    nextPage(): void;
+    /** Navigate to specific page */
+    goToPage(page: number | string): void;
+    /** Handle page size change */
+    onPageSizeChange(event: Event): void;
+    private changePage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaPaginatorComponent, "matcha-paginator", never, { "pageIndex": { "alias": "pageIndex"; "required": false; }; "length": { "alias": "length"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "page": "page"; }, never, never, false, never>;
+}
+
+declare class MatchaHighlightComponent implements OnInit, OnDestroy {
+    private _elementRef;
+    private _httpClient;
+    source: ElementRef;
+    lang: string;
+    path: string;
+    theme: string;
+    get themeAttr(): string;
+    private _unsubscribeAll;
+    /**
+     * Constructor
+     *
+     * @param {ElementRef} _elementRef
+     * @param {HttpClient} _httpClient
+     */
+    constructor(_elementRef: ElementRef, _httpClient: HttpClient);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Apply theme to the component
+     */
+    /**
+     * Highlight the given source code
+     *
+     * @param sourceCode
+     */
+    highlight(sourceCode: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaHighlightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatchaHighlightComponent, "matcha-highlight", never, { "lang": { "alias": "lang"; "required": false; }; "path": { "alias": "path"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, {}, ["source"], ["*"], false, never>;
+}
+
+declare class CopyButtonComponent {
+    private elementRef;
+    type: string;
+    size: 'tiny' | 'small' | 'medium' | 'large';
+    icon: string;
+    position: 'absolute' | 'relative';
+    customClass: string;
+    copied: EventEmitter<{
+        text: string;
+        type: string;
+    }>;
+    currentIcon: string;
+    isCopied: boolean;
+    copyToClipboard(): Promise<void>;
+    private fallbackCopyToClipboard;
+    private showCopyFeedback;
+    getButtonClasses(): string;
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CopyButtonComponent, "matcha-copy-button", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; }, { "copied": "copied"; }, 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 MatchaAutocompleteTriggerDirective implements AfterViewInit, OnDestroy {
+    private el;
+    panel: MatchaAutocompleteComponent;
+    private subs;
+    constructor(el: ElementRef<HTMLInputElement>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private writeValueToInput;
+    onClick(): void;
+    onFocus(): void;
+    onInput(e: Event): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onDocClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaAutocompleteTriggerDirective, "[matchaAutocomplete]", never, { "panel": { "alias": "matchaAutocomplete"; "required": false; }; }, {}, never, 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 MatchaPanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaPanelModule, [typeof MatchaPanelComponent], [typeof i2.CommonModule], [typeof MatchaPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaPanelModule>;
+}
+
+declare class MatchaAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaAutocompleteModule, [typeof MatchaAutocompleteComponent, typeof MatchaAutocompleteTriggerDirective], [typeof i2.CommonModule, typeof MatchaOptionModule, typeof MatchaPanelModule], [typeof MatchaAutocompleteComponent, typeof MatchaAutocompleteTriggerDirective, typeof MatchaOptionModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaAutocompleteModule>;
+}
+
+declare class MatchaSelectTriggerDirective implements AfterViewInit, OnDestroy {
+    private el;
+    select: MatchaSelectComponent;
+    private subs;
+    constructor(el: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private writeValueToInput;
+    onClick(): void;
+    onFocus(): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onDocClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSelectTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatchaSelectTriggerDirective, "[matchaSelect]", never, { "select": { "alias": "matchaSelect"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatchaSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaSelectModule, [typeof MatchaSelectComponent, typeof MatchaSelectTriggerDirective], [typeof i2.CommonModule, typeof MatchaOptionModule, typeof MatchaPanelModule], [typeof MatchaSelectComponent, typeof MatchaSelectTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaSelectModule>;
+}
+
+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 MatchaRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaRadioModule, [typeof MatchaRadioComponent], [typeof i2.CommonModule, typeof MatchaRippleModule], [typeof MatchaRadioComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaRadioModule>;
+}
+
+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 MatchaPaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaPaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaPaginatorModule, [typeof MatchaPaginatorComponent], [typeof i2.CommonModule, typeof MatchaIconModule], [typeof MatchaPaginatorComponent]>;
+    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 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 MatchaDateRangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDateRangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDateRangeModule, [typeof MatchaDateRangeComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule], [typeof MatchaDateRangeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDateRangeModule>;
+}
+
+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 MatchaDrawerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaDrawerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaDrawerModule, [typeof MatchaDrawerComponent, typeof MatchaDrawerContainerComponent, typeof MatchaDrawerContentComponent], [typeof i2.CommonModule, typeof MatchaButtonModule], [typeof MatchaDrawerComponent, typeof MatchaDrawerContainerComponent, typeof MatchaDrawerContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaDrawerModule>;
+}
+
+declare class MatchaHighlightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaHighlightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaHighlightModule, [typeof MatchaHighlightComponent, typeof CopyButtonComponent], [typeof MatchaIconModule, typeof MatchaButtonModule], [typeof MatchaHighlightComponent, typeof CopyButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaHighlightModule>;
+}
+
+declare class MatchaAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaAvatarModule, [typeof MatchaAvatarComponent], [typeof i2.CommonModule], [typeof MatchaAvatarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaAvatarModule>;
+}
+
+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 MatchaAutocompleteModule, typeof MatchaOptionModule, typeof MatchaPanelModule, typeof MatchaSelectModule, typeof MatchaBadgeModule, typeof MatchaButtonModule, typeof MatchaButtonToggleModule, typeof MatchaCardModule, typeof MatchaCheckboxModule, typeof MatchaRadioModule, 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 MatchaRippleModule, 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 MatchaDateRangeModule, typeof MatchaTimeModule, typeof MatchaDropListModule, typeof MatchaPageLayoutModule, typeof MatchaDrawerModule, typeof MatchaHighlightModule], [typeof MatchaAccordionModule, typeof MatchaAutocompleteModule, typeof MatchaOptionModule, typeof MatchaPanelModule, typeof MatchaSelectModule, typeof MatchaBadgeModule, typeof MatchaButtonModule, typeof MatchaButtonToggleModule, typeof MatchaCardModule, typeof MatchaCheckboxModule, typeof MatchaRadioModule, 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 MatchaRippleModule, 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 MatchaDateRangeModule, typeof MatchaTimeModule, typeof MatchaDropListModule, typeof MatchaPageLayoutModule, typeof MatchaAvatarModule, typeof MatchaDrawerModule, typeof MatchaHighlightModule]>;
+    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>;
+}
+
+/**
+ * Módulo para o MatchaBreakpointObserver
+ *
+ * Este módulo fornece o serviço MatchaBreakpointObserver que pode ser usado
+ * em qualquer parte da aplicação para observar breakpoints CSS.
+ *
+ * O serviço é um singleton (providedIn: 'root') e não precisa ser importado
+ * explicitamente, mas este módulo pode ser usado para organização.
+ */
+declare class MatchaBreakpointObservableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchaBreakpointObservableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatchaBreakpointObservableModule, never, [typeof i2.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatchaBreakpointObservableModule>;
+}
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+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 { CopyButtonComponent, MATCHA_OPTION_PARENT, MatchaAccordionComponent, MatchaAccordionContentComponent, MatchaAccordionHeaderComponent, MatchaAccordionItemComponent, MatchaAccordionModule, MatchaAutocompleteComponent, MatchaAutocompleteModule, MatchaAutocompleteTriggerDirective, MatchaAvatarComponent, MatchaAvatarModule, MatchaBadgeDirective, MatchaBadgeModule, MatchaBreakpointObservableModule, MatchaBreakpointObserver, MatchaButtonComponent, MatchaButtonModule, MatchaButtonToggleComponent, MatchaButtonToggleModule, MatchaCardComponent, MatchaCardModule, MatchaCheckboxComponent, MatchaCheckboxModule, MatchaComponentsModule, MatchaDateRangeComponent, MatchaDateRangeModule, MatchaDividerComponent, MatchaDividerModule, MatchaDragDirective, MatchaDragHandleDirective, MatchaDrawerComponent, MatchaDrawerContainerComponent, MatchaDrawerContentComponent, MatchaDrawerModule, MatchaDropListComponent, MatchaDropListModule, MatchaElevationDirective, MatchaElevationModule, MatchaErrorComponent, MatchaFormFieldComponent, MatchaFormFieldModule, MatchaGridComponent, MatchaGridModule, MatchaHighlightComponent, MatchaHighlightModule, 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, MatchaOverlayService, MatchaPageLayoutComponent, MatchaPageLayoutModule, MatchaPaginatorComponent, MatchaPaginatorIntl, MatchaPaginatorModule, MatchaPanelComponent, MatchaPanelModule, MatchaProgressBarDirective, MatchaProgressBarModule, MatchaRadioComponent, MatchaRadioModule, MatchaRippleDirective, MatchaRippleModule, MatchaSelectComponent, MatchaSelectModule, MatchaSelectTriggerDirective, 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 { BreakpointState, DrawerItem, DrawerMode, DrawerPosition, DrawerSection, ILevelClasses, MatchaDropListConnectedToEvent, MatchaDropListDroppedEvent, MatchaOptionParent, ModalComponent, PageEvent, PanelPlacement, PanelPosition };