angular-matecu 4.1.0 → 4.2.0

package/types/angular-matecu.d.ts

@@ -0,0 +1,490 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ChangeDetectorRef, AfterViewInit, EventEmitter, ElementRef, NgZone, OnChanges, DoCheck, Injector, SimpleChanges } from '@angular/core';
+import * as i1 from '@angular/common';
+import { Observable, Subject } from 'rxjs';
+import * as i2 from '@angular/material/toolbar';
+import * as i3 from '@angular/material/icon';
+import * as i4 from '@angular/forms';
+import { FormControl, ControlValueAccessor, NgControl } from '@angular/forms';
+import * as i5 from '@angular/material/button';
+import * as i3$1 from '@angular/material/dialog';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i5$1 from '@angular/material/snack-bar';
+import { MatSnackBarRef, MatSnackBar, MatSnackBarConfig, TextOnlySnackBar } from '@angular/material/snack-bar';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { MatAutocompleteTrigger } from '@angular/material/autocomplete';
+
+declare class MatecuSpinnerService {
+    private active$;
+    private requestsKeys;
+    constructor();
+    watch(): Observable<boolean>;
+    add(customKey?: string): string;
+    remove(key: string): void;
+    clear(): void;
+    private updateStatus;
+    private createKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuSpinnerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatecuSpinnerService>;
+}
+
+declare class MatecuSpinnerComponent implements OnInit, OnDestroy {
+    private spinnerService;
+    private cdr;
+    private destroy$;
+    private hiddenClass;
+    private activeCache;
+    className: string;
+    color: string;
+    global: boolean;
+    get active(): boolean;
+    set active(value: boolean);
+    size: string;
+    constructor(spinnerService: MatecuSpinnerService, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuSpinnerComponent, "matecu-spinner", never, { "color": { "alias": "color"; "required": false; }; "global": { "alias": "global"; "required": false; }; "active": { "alias": "active"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MatecuSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatecuSpinnerModule, never, [typeof i1.CommonModule, typeof MatecuSpinnerComponent], [typeof MatecuSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatecuSpinnerModule>;
+}
+
+declare class MatecuTopbarLayoutComponent implements AfterViewInit, OnDestroy {
+    private elementRef;
+    private changeDetector;
+    private zone;
+    private _scrolled;
+    private _prominent;
+    get scrolled(): boolean;
+    set scrolled(value: boolean);
+    private destroy$;
+    mobileStyle: boolean;
+    mobileStyleChange: EventEmitter<boolean>;
+    mobileWidth: number;
+    whenResize: EventEmitter<number>;
+    get prominent(): boolean;
+    set prominent(value: boolean);
+    className: string;
+    bodyElement?: ElementRef;
+    constructor(elementRef: ElementRef, changeDetector: ChangeDetectorRef, zone: NgZone);
+    ngOnDestroy(): void;
+    private spyScroll;
+    ngAfterViewInit(): void;
+    scrollTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarLayoutComponent, "matecu-topbar-layout", never, { "mobileStyle": { "alias": "mobileStyle"; "required": false; }; "mobileWidth": { "alias": "mobileWidth"; "required": false; }; "prominent": { "alias": "prominent"; "required": false; }; }, { "mobileStyleChange": "mobileStyleChange"; "whenResize": "whenResize"; }, never, ["matecu-topbar-header-row[first-row]", "matecu-topbar-header-row[second-row]", "matecu-topbar-body"], true, never>;
+}
+
+declare class MatecuTopbarTitleComponent implements OnInit {
+    className: string;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarTitleComponent, "matecu-topbar-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MatecuTopbarBodyComponent {
+    className: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarBodyComponent, "matecu-topbar-body", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MatecuTopbarFabComponent {
+    private _mobileStyle;
+    private mainClassName;
+    display: boolean;
+    get mobileStyle(): boolean;
+    set mobileStyle(value: boolean);
+    className: string;
+    get color(): "flex" | "none";
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarFabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarFabComponent, "matecu-topbar-fab", never, { "display": { "alias": "display"; "required": false; }; "mobileStyle": { "alias": "mobileStyle"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MatecuTopbarSearchComponent implements OnInit {
+    hasValue: boolean;
+    activeMobileSearch: boolean;
+    inputCtrl: FormControl<string | null>;
+    private _value;
+    private _mobileStyle;
+    private destroy$;
+    display: boolean;
+    placeholder: string;
+    delyValueChanges: number;
+    get value(): string;
+    set value(v: string);
+    get mobileStyle(): boolean;
+    set mobileStyle(value: boolean);
+    valueChange: EventEmitter<string>;
+    className: string;
+    get color(): "flex" | "none";
+    ngOnInit(): void;
+    toggleActiveMobildeSearch(): void;
+    clearSearch(): void;
+    updateHasValueFn(): (value: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarSearchComponent, "matecu-topbar-search", never, { "display": { "alias": "display"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "delyValueChanges": { "alias": "delyValueChanges"; "required": false; }; "value": { "alias": "value"; "required": false; }; "mobileStyle": { "alias": "mobileStyle"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class MatecuTopbarActionComponent implements OnInit {
+    className: string;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarActionComponent, "matecu-topbar-action", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MatecuTopbarHeaderRowComponent {
+    display: boolean;
+    className: string;
+    get color(): "flex" | "none";
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarHeaderRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarHeaderRowComponent, "matecu-topbar-header-row", never, { "display": { "alias": "display"; "required": false; }; }, {}, never, ["matecu-topbar-header-column[left-column]", "matecu-topbar-header-column[right-column]"], true, never>;
+}
+
+declare class MatecuTopbarHeaderColumnComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarHeaderColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuTopbarHeaderColumnComponent, "matecu-topbar-header-column", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MatecuTopbarLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuTopbarLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatecuTopbarLayoutModule, never, [typeof i1.CommonModule, typeof i2.MatToolbarModule, typeof i3.MatIconModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.MatButtonModule, typeof MatecuTopbarLayoutComponent, typeof MatecuTopbarTitleComponent, typeof MatecuTopbarBodyComponent, typeof MatecuTopbarFabComponent, typeof MatecuTopbarSearchComponent, typeof MatecuTopbarActionComponent, typeof MatecuTopbarHeaderRowComponent, typeof MatecuTopbarHeaderColumnComponent], [typeof MatecuTopbarLayoutComponent, typeof MatecuTopbarTitleComponent, typeof MatecuTopbarBodyComponent, typeof MatecuTopbarFabComponent, typeof MatecuTopbarSearchComponent, typeof MatecuTopbarActionComponent, typeof MatecuTopbarHeaderRowComponent, typeof MatecuTopbarHeaderColumnComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatecuTopbarLayoutModule>;
+}
+
+declare enum MatecuAlertBoxType {
+    warning = "warning",
+    success = "success",
+    danger = "danger",
+    info = "info"
+}
+
+declare class MatecuAlertBoxComponent implements OnInit {
+    classNameBase: string;
+    alertColor?: MatecuAlertBoxType | undefined | string | null;
+    iconValue?: string | null | undefined;
+    private alertIcon;
+    get color(): MatecuAlertBoxType | undefined | string | null;
+    set color(value: MatecuAlertBoxType | undefined | string | null);
+    get icon(): boolean;
+    set icon(value: boolean);
+    className: string;
+    constructor();
+    ngOnInit(): void;
+    private updateIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAlertBoxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuAlertBoxComponent, "matecu-alert-box", never, { "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface MatecuAlertDialogData {
+    message: string;
+    title?: string | null | undefined;
+    action?: string | null | undefined;
+    icon?: boolean | null | undefined;
+    type?: MatecuAlertBoxType | string | null | undefined;
+    dismissText?: string | null | undefined;
+}
+
+declare class MatecuAlertDialogComponent implements OnInit {
+    dialogData: MatecuAlertDialogData;
+    dialogRef: MatDialogRef<MatecuAlertDialogComponent>;
+    hasTitle: boolean;
+    hasDismissBtn: boolean;
+    hasActionBtn: boolean;
+    showActions: boolean;
+    constructor(dialogData: MatecuAlertDialogData, dialogRef: MatDialogRef<MatecuAlertDialogComponent>);
+    ngOnInit(): void;
+    activateAction(): void;
+    private setHasTitle;
+    private setHasDismissBtn;
+    private setHasActionBtn;
+    private setShowActions;
+    private isValidString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAlertDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuAlertDialogComponent, "matecu-alert-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface MatecuAlertSnackBarData {
+    message: string;
+    title: string;
+    action?: string;
+    type: MatecuAlertBoxType;
+}
+
+declare class MatecuAlertSnackBarComponent {
+    data: MatecuAlertSnackBarData;
+    private snackBarRef;
+    title: string;
+    message: string;
+    action?: string;
+    classNameBase: string;
+    alertColor: MatecuAlertBoxType;
+    get color(): MatecuAlertBoxType;
+    set color(value: MatecuAlertBoxType);
+    className: string;
+    constructor(data: MatecuAlertSnackBarData, snackBarRef: MatSnackBarRef<MatecuAlertSnackBarComponent>);
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAlertSnackBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuAlertSnackBarComponent, "matecu-alert-snack-bar", never, {}, {}, never, never, true, never>;
+}
+
+declare class MatecuAlertBoxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAlertBoxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatecuAlertBoxModule, never, [typeof i1.CommonModule, typeof i3.MatIconModule, typeof i3$1.MatDialogModule, typeof i5.MatButtonModule, typeof i5$1.MatSnackBarModule, typeof MatecuAlertBoxComponent, typeof MatecuAlertDialogComponent, typeof MatecuAlertSnackBarComponent], [typeof MatecuAlertBoxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatecuAlertBoxModule>;
+}
+
+declare class MatecuSnackBarService {
+    private snackBar;
+    constructor(snackBar: MatSnackBar);
+    openError(error: string | Error, title?: string | null, action?: string, config?: MatSnackBarConfig<any>): MatSnackBarRef<MatecuAlertSnackBarComponent>;
+    openSuccess(message: string, title?: string | null, action?: string, config?: MatSnackBarConfig<any>): MatSnackBarRef<MatecuAlertSnackBarComponent>;
+    openWarning(message: string, title?: string | null, action?: string, config?: MatSnackBarConfig<any>): MatSnackBarRef<MatecuAlertSnackBarComponent>;
+    openInfo(message: string, title?: string | null, action?: string, config?: MatSnackBarConfig<any>): MatSnackBarRef<MatecuAlertSnackBarComponent>;
+    open(message: string, action?: string, config?: MatSnackBarConfig<any>): MatSnackBarRef<TextOnlySnackBar>;
+    dismiss(): void;
+    private openAlert;
+    private getErrorMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuSnackBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatecuSnackBarService>;
+}
+
+/**
+ * [value,label]
+ */
+type MatecuAutocompleteOption = [string, string];
+type MatecuAutocompleteFilterFn = (optionLabel: string, search: string) => boolean;
+
+declare class MatecuAutocomplete implements ControlValueAccessor, MatFormFieldControl<string>, OnChanges, OnInit, OnDestroy, DoCheck {
+    options: MatecuAutocompleteOption[];
+    allowCreate: boolean;
+    loading: boolean;
+    readonly: boolean;
+    filterFn: MatecuAutocompleteFilterFn;
+    searchChangeDebounceTime: number;
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    get value(): string | null;
+    set value(value: string | null);
+    searchChange: EventEmitter<string>;
+    create: EventEmitter<string>;
+    valueChange: EventEmitter<string | null>;
+    static nextId: number;
+    readonly stateChanges: Subject<void>;
+    readonly id: string;
+    ngControl: NgControl | null;
+    focused: boolean;
+    lastSearchText: string | null;
+    readonly controlType = "matecu-autocomplete";
+    readonly autofilled = false;
+    inputControl: FormControl<string | null>;
+    filteredOptions$: Observable<MatecuAutocompleteOption[]>;
+    private internalValue;
+    private focusMonitor;
+    private elementRef;
+    private injector;
+    private optionMap;
+    private onChange;
+    private onTouched;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get errorState(): boolean;
+    get showCreateOption(): boolean;
+    constructor(focusMonitor: FocusMonitor, elementRef: ElementRef<HTMLElement>, injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private filter;
+    private createFilterFn;
+    displayLabel: (value: string | null) => string;
+    onOptionSelected(value: string): void;
+    onCreateClick(): void;
+    private updateInputLabelFromValue;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    focus(options?: FocusOptions): void;
+    onContainerClick(): void;
+    setDescribedByIds(ids: string[]): void;
+    private rebuildOptionMap;
+    private clearValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAutocomplete, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuAutocomplete, "matecu-autocomplete", never, { "options": { "alias": "options"; "required": false; }; "allowCreate": { "alias": "allowCreate"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "searchChangeDebounceTime": { "alias": "searchChangeDebounceTime"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "searchChange": "searchChange"; "create": "create"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class MatecuAutocompleteMultiple implements ControlValueAccessor, MatFormFieldControl<string[]>, OnDestroy, OnInit {
+    static nextId: number;
+    placeholder: string;
+    loading: boolean;
+    searchChangeDebounceTime: number;
+    enableSelectAll: boolean;
+    readonly: boolean;
+    selectAllLabel: string;
+    clearAllLabel: string;
+    showTooltip: boolean;
+    filterFn: MatecuAutocompleteFilterFn;
+    private _options;
+    set options(value: MatecuAutocompleteOption[]);
+    get options(): MatecuAutocompleteOption[];
+    searchChange: EventEmitter<string>;
+    valueChange: EventEmitter<string[] | null>;
+    control: FormControl<string[]>;
+    controlValue$: i0.Signal<string[] | undefined>;
+    searchControl: FormControl<string>;
+    autocompleteTrigger: MatAutocompleteTrigger;
+    readonly searchText: i0.WritableSignal<string>;
+    readonly filteredOptions: i0.Signal<MatecuAutocompleteOption[]>;
+    readonly selectedItems: i0.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    stateChanges: Subject<void>;
+    focused: boolean;
+    controlType: string;
+    id: string;
+    describedBy: string;
+    disabled: boolean;
+    required: boolean;
+    errorState: boolean;
+    private injector;
+    ngControl: NgControl | null;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    constructor(injector: Injector);
+    value: string[] | null;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    describedByIds?: string[] | undefined;
+    ngOnInit(): void;
+    selectOption(option: [string, string]): void;
+    displayLabel(option: [string, string]): string;
+    remove(value: string): void;
+    selectAll(): void;
+    clearAll(): void;
+    drop(event: CdkDragDrop<any>): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onChange: (value: string[]) => void;
+    onTouched: () => void;
+    writeValue(value: string[] | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    ngOnDestroy(): void;
+    trackByValue: (_: number, item: [string, string]) => string;
+    openPanel(): void;
+    private createFilterFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuAutocompleteMultiple, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuAutocompleteMultiple, "matecu-autocomplete-multiple", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "searchChangeDebounceTime": { "alias": "searchChangeDebounceTime"; "required": false; }; "enableSelectAll": { "alias": "enableSelectAll"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; }; "clearAllLabel": { "alias": "clearAllLabel"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "options": { "alias": "options"; "required": true; }; }, { "searchChange": "searchChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface ErrorMessages {
+    invalidSize: string;
+    invalidType: string;
+    tooManyFiles: string;
+    uploadError: string;
+}
+type FileSizeUnit = 'AUTO' | 'bytes' | 'KB' | 'MB' | 'GB' | 'TB';
+
+declare enum FileInputState {
+    IDLE = "idle",
+    LOADING = "loading",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+declare class MatecuFileInput implements ControlValueAccessor, OnDestroy {
+    fileInput: ElementRef<HTMLInputElement>;
+    files: File[];
+    file?: File;
+    isDisabled: boolean;
+    fileName?: string;
+    selectedFileSize?: number;
+    hasInvalidSize: boolean;
+    hasInvalidType: boolean;
+    previewUrl?: string;
+    previewUrls: Map<string, string>;
+    currentState: FileInputState;
+    validationErrors: string[];
+    isDragOver: boolean;
+    private onChange;
+    private onTouched;
+    optimizeImage?: (img: File) => Promise<File>;
+    optimizeImageToSize?: number;
+    maxFileSize?: number;
+    maxFiles: number;
+    multiple: boolean;
+    showFileSize: boolean;
+    fileSizeUnit: FileSizeUnit;
+    displayName?: string;
+    placeholder: string;
+    buttonText: string;
+    changeSelectedFileText: string;
+    loadingText: string;
+    ariaLabel?: string;
+    acceptedMimeTypes: string[];
+    acceptedExtensions: string[];
+    errorMessages: ErrorMessages;
+    enableDragDrop: boolean;
+    showPreview: boolean;
+    previewMaxWidth: number;
+    previewMaxHeight: number;
+    showProgress: boolean;
+    fileSelected: EventEmitter<File>;
+    filesSelected: EventEmitter<File[]>;
+    fileRemoved: EventEmitter<File>;
+    validationError: EventEmitter<string[]>;
+    dragEnter: EventEmitter<DragEvent>;
+    dragLeave: EventEmitter<DragEvent>;
+    stateChange: EventEmitter<FileInputState>;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    onFileChange(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    openFileDialog(): void;
+    removeFile(fileToRemove: File): void;
+    private handleFileSelection;
+    private handleSingleFile;
+    private handleMultipleFiles;
+    private processFile;
+    private validateFile;
+    private generatePreview;
+    private cleanupPreview;
+    private resetComponent;
+    private notifyChange;
+    private changeState;
+    calculateFileSizeInMB(file: File): number;
+    formatFileSize(file: File): string;
+    getFileIcon(file?: File): string;
+    getPreviewUrl(file: File): string;
+    get hasErrors(): boolean;
+    get isLoading(): boolean;
+    get hasFiles(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatecuFileInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatecuFileInput, "matecu-file-input", never, { "optimizeImage": { "alias": "optimizeImage"; "required": false; }; "optimizeImageToSize": { "alias": "optimizeImageToSize"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "showFileSize": { "alias": "showFileSize"; "required": false; }; "fileSizeUnit": { "alias": "fileSizeUnit"; "required": false; }; "displayName": { "alias": "displayName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "changeSelectedFileText": { "alias": "changeSelectedFileText"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "acceptedMimeTypes": { "alias": "acceptedMimeTypes"; "required": false; }; "acceptedExtensions": { "alias": "acceptedExtensions"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "enableDragDrop": { "alias": "enableDragDrop"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; "previewMaxWidth": { "alias": "previewMaxWidth"; "required": false; }; "previewMaxHeight": { "alias": "previewMaxHeight"; "required": false; }; "showProgress": { "alias": "showProgress"; "required": false; }; }, { "fileSelected": "fileSelected"; "filesSelected": "filesSelected"; "fileRemoved": "fileRemoved"; "validationError": "validationError"; "dragEnter": "dragEnter"; "dragLeave": "dragLeave"; "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+export { FileInputState, MatecuAlertBoxComponent, MatecuAlertBoxModule, MatecuAlertBoxType, MatecuAlertDialogComponent, MatecuAlertSnackBarComponent, MatecuAutocomplete, MatecuAutocompleteMultiple, MatecuFileInput, MatecuSnackBarService, MatecuSpinnerComponent, MatecuSpinnerModule, MatecuSpinnerService, MatecuTopbarActionComponent, MatecuTopbarBodyComponent, MatecuTopbarFabComponent, MatecuTopbarHeaderColumnComponent, MatecuTopbarHeaderRowComponent, MatecuTopbarLayoutComponent, MatecuTopbarLayoutModule, MatecuTopbarSearchComponent, MatecuTopbarTitleComponent };
+export type { FileSizeUnit, MatecuAlertDialogData };

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../dist/angular-matecu",
-  "lib": {
-    "entryFile": "src/public-api.ts"
-  }
-}

package/src/css/main.css

@@ -1 +0,0 @@
-.matecu-spinner{display:inline-flex;justify-content:center;align-content:center}.matecu-spinner__hidden{display:none}

package/src/lib/components/matecu-alert-box/matecu-alert-box.component.html

@@ -1,11 +0,0 @@
-@if (icon && iconValue) {
-<div class="matecu-alert-box__icon">
-  <mat-icon>{{iconValue}}</mat-icon>
-</div>
-}
-<div class="matecu-alert-box__content">
-  <ng-content>
-
-
-  </ng-content>
-</div>

package/src/lib/components/matecu-alert-box/matecu-alert-box.component.scss

@@ -1,39 +0,0 @@
-:host.matecu-alert-box {
-  display: flex;
-  padding: 1rem;
-  border-radius: 0.25rem;
-  position: relative;
-  border: 1px solid rgb(224, 224, 224);
-  box-sizing: border-box;
-  margin: 1rem 0;
-
-  &--success {
-    color: rgb(15, 80, 50);
-    background-color: rgb(210, 230, 220);
-    border-color: rgb(186, 220, 205);
-  }
-  &--danger {
-    color: rgb(130, 30, 40);
-    background-color: rgb(248, 215, 218);
-    border-color: rgb(245, 194, 199);
-  }
-  &--warning {
-    color: rgb(100, 77, 3);
-    background-color: rgb(255, 243, 205);
-    border-color: rgb(255, 236, 180);
-  }
-  &--info {
-    color: rgb(5, 81, 96);
-    background-color: rgb(207, 244, 252);
-    border-color: rgb(182, 239, 251);
-  }
-  .matecu-alert-box {
-    &__icon {
-      display: flex;
-      margin-right: 1rem;
-    }
-    &__content {
-      align-self: center;
-    }
-  }
-}

package/src/lib/components/matecu-alert-box/matecu-alert-box.component.spec.ts

@@ -1,25 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { MatecuAlertBoxComponent } from './matecu-alert-box.component';
-
-describe('MatecuAlertBoxComponent', () => {
-  let component: MatecuAlertBoxComponent;
-  let fixture: ComponentFixture<MatecuAlertBoxComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [ MatecuAlertBoxComponent ]
-    })
-    .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(MatecuAlertBoxComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

package/src/lib/components/matecu-alert-box/matecu-alert-box.component.ts

@@ -1,60 +0,0 @@
-import { CommonModule } from '@angular/common';
-import { Component, HostBinding, Input, OnInit } from '@angular/core';
-import { MatIconModule } from '@angular/material/icon';
-import { MatecuAlertBoxType } from '../../types/matecu-altert-box-type';
-
-@Component({
-  selector: 'matecu-alert-box',
-  templateUrl: './matecu-alert-box.component.html',
-  styleUrls: ['./matecu-alert-box.component.scss'],
-  standalone: true,
-  imports: [CommonModule, MatIconModule]
-})
-export class MatecuAlertBoxComponent implements OnInit {
-  classNameBase = 'matecu-alert-box';
-  alertColor?: MatecuAlertBoxType | undefined | string | null;
-  iconValue?: string | null | undefined;
-  private alertIcon = false;
-  get color(): MatecuAlertBoxType | undefined | string | null {
-    return this.alertColor;
-  }
-  @Input() set color(value: MatecuAlertBoxType | undefined | string | null) {
-    this.alertColor = value;
-    if (!!value) {
-      this.className = `${this.classNameBase} ${this.classNameBase}--${value}`;
-    } else {
-      this.className = this.classNameBase;
-    }
-    this.updateIcon();
-  }
-  get icon(): boolean {
-    return this.alertIcon;
-  }
-  @Input() set icon(value: boolean) {
-    this.alertIcon = value;
-  }
-  @HostBinding('class') className = this.classNameBase;
-  constructor() { }
-
-  ngOnInit(): void { }
-
-  private updateIcon(): void {
-    switch (this.color) {
-      case MatecuAlertBoxType.danger:
-        this.iconValue = 'dangerous';
-        break;
-      case MatecuAlertBoxType.warning:
-        this.iconValue = 'warning';
-        break;
-      case MatecuAlertBoxType.success:
-        this.iconValue = 'check_circle';
-        break;
-      case MatecuAlertBoxType.info:
-        this.iconValue = 'info';
-        break;
-      default:
-        this.iconValue = null;
-        break;
-    }
-  }
-}

package/src/lib/components/matecu-alert-dialog/matecu-alert-dialog.component.html

@@ -1,24 +0,0 @@
-@if (hasTitle) {
-
-<h2 mat-dialog-title>{{dialogData.title}}</h2>
-}
-<mat-dialog-content>
-
-  <matecu-alert-box [color]="dialogData.type" [icon]="!!dialogData.icon">
-    {{dialogData.message}}
-  </matecu-alert-box>
-
-</mat-dialog-content>
-@if (showActions) {
-
-<mat-dialog-actions align="end">
-  @if (hasDismissBtn) {
-  <button mat-button color="primary" tabindex="-1" mat-dialog-close>{{dialogData.dismissText}}
-  </button>
-  }
-  @if(hasActionBtn) {
-  <button mat-button color="primary" tabindex="-2" (click)="activateAction()">{{dialogData.action}}
-  </button>
-  }
-</mat-dialog-actions>
-}

package/src/lib/components/matecu-alert-dialog/matecu-alert-dialog.component.scss

@@ -1,5 +0,0 @@
-:host {
-  matecu-alert-box {
-    max-width: 900px;
-  }
-}