import * as i0 from '@angular/core';
import { OnInit, EventEmitter, InputSignal, OutputEmitterRef, Signal, WritableSignal, OnDestroy, DoCheck, ElementRef, TemplateRef, AfterContentInit, ViewContainerRef } from '@angular/core';
import * as i4 from '@angular/forms';
import { ControlValueAccessor, AbstractControl, ValidatorFn, UntypedFormGroup, UntypedFormBuilder, FormControl, FormGroup, NgControl, NgForm, FormGroupDirective, FormControlDirective, FormControlName, UntypedFormControl } from '@angular/forms';
import { SubscriptSizing, MatFormFieldControl } from '@angular/material/form-field';
import { Clipboard } from '@angular/cdk/clipboard';
import { ComponentType } from '@angular/cdk/portal';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { BooleanInput } from '@angular/cdk/coercion';
import { MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import * as i3 from '@angular/common';
import { Configuration } from '@cauca-911/core';

declare class CaucaMaterialService {
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaMaterialService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaucaMaterialService>;
}

declare class CaucaMaterialComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaMaterialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaMaterialComponent, "cauca-material", never, {}, {}, never, never, true, never>;
}

declare class CaucaDateTimePickerComponent implements ControlValueAccessor, OnInit {
    subscriptSizing: SubscriptSizing;
    showTime: boolean;
    label: string;
    translateLabel: boolean;
    stepHours: number;
    stepMinutes: number;
    stepSecondes: number;
    minimumDate: Date;
    maximumDate: Date;
    showSeconds: boolean;
    showFormat: string;
    showClearButton: boolean;
    showButtonIcons: boolean;
    selectedChange: EventEmitter<Date>;
    control: AbstractControl;
    stringDate: string;
    private readonly injector;
    private readonly elementRef;
    private readonly dialog;
    private readonly datePipe;
    private selectedDate;
    set value(value: Date);
    get isRequired(): boolean;
    ngOnInit(): void;
    showDialog(): void;
    writeValue(date: Date): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onChange: (value: Date) => Date;
    onTouched: () => void;
    private getDateTimePickerOptions;
    private stringifyDate;
    private getDialogPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaDateTimePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaDateTimePickerComponent, "cauca-date-time-picker", never, { "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "label": { "alias": "label"; "required": false; }; "translateLabel": { "alias": "translateLabel"; "required": false; }; "stepHours": { "alias": "stepHours"; "required": false; }; "stepMinutes": { "alias": "stepMinutes"; "required": false; }; "stepSecondes": { "alias": "stepSecondes"; "required": false; }; "minimumDate": { "alias": "minimumDate"; "required": false; }; "maximumDate": { "alias": "maximumDate"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "showFormat": { "alias": "showFormat"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "showButtonIcons": { "alias": "showButtonIcons"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
}

declare abstract class BaseButton {
    colorOnHover: InputSignal<string>;
    color: InputSignal<string>;
    icon: InputSignal<string>;
    iconAlignment: InputSignal<'left' | 'right'>;
    isDisabled: InputSignal<boolean>;
    isInProgress: InputSignal<boolean>;
    iconColor: i0.Signal<string>;
    showIcon: i0.Signal<boolean>;
    iconToShow: i0.Signal<string>;
    buttonDisabled: i0.Signal<boolean>;
    buttonClick: OutputEmitterRef<void>;
    isHovered: i0.WritableSignal<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseButton, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseButton, never, never, { "colorOnHover": { "alias": "colorOnHover"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "isInProgress": { "alias": "isInProgress"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
}
declare abstract class BaseButtonWithLabel extends BaseButton {
    translateLabel: InputSignal<boolean>;
    label: InputSignal<string>;
    small: InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseButtonWithLabel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseButtonWithLabel, never, never, { "translateLabel": { "alias": "translateLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class BasicButtonComponent extends BaseButtonWithLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<BasicButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BasicButtonComponent, "cauca-basic-button", never, {}, {}, never, never, true, never>;
}

declare class FabButtonComponent extends BaseButtonWithLabel {
    iconColor: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FabButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FabButtonComponent, "cauca-fab-button", never, {}, {}, never, never, true, never>;
}

declare class FlatButtonComponent extends BaseButtonWithLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<FlatButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlatButtonComponent, "cauca-flat-button", never, {}, {}, never, never, true, never>;
}

declare class IconButtonComponent extends BaseButton {
    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconButtonComponent, "cauca-icon-button", never, {}, {}, never, never, true, never>;
}

declare class LinkButtonComponent {
    private readonly clipboard;
    readonly segments: i0.InputSignal<string[]>;
    constructor(clipboard: Clipboard);
    copyLink(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkButtonComponent, "cauca-link-button", never, { "segments": { "alias": "segments"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MenuItemComponent extends BaseButtonWithLabel {
    translateLabel: InputSignal<boolean>;
    trigger: InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "cauca-menu-item", never, { "translateLabel": { "alias": "translateLabel"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RaisedButtonComponent extends BaseButtonWithLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<RaisedButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RaisedButtonComponent, "cauca-raised-button", never, {}, {}, never, never, true, never>;
}

declare class RefreshButtonComponent {
    inProgress: boolean;
    refreshEvent: EventEmitter<void>;
    refresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefreshButtonComponent, "cauca-refresh-button", never, { "inProgress": { "alias": "inProgress"; "required": false; }; }, { "refreshEvent": "refreshEvent"; }, never, never, true, never>;
}

declare class RoundButtonComponent extends BaseButtonWithLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<RoundButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RoundButtonComponent, "cauca-round-button", never, {}, {}, never, never, true, never>;
}

declare class StrokedButtonComponent extends BaseButtonWithLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<StrokedButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StrokedButtonComponent, "cauca-stroked-button", never, {}, {}, never, never, true, never>;
}

declare class ButtonComponent {
    class: string | null;
    inProgress: boolean;
    disable: boolean;
    label: string;
    icon: string | null;
    color: string;
    type: 'basic' | 'raised' | 'stroked' | 'flat' | 'icon' | 'fab';
    buttonClick: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "cauca-button", never, { "class": { "alias": "class"; "required": false; }; "inProgress": { "alias": "inProgress"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "color": { "alias": "color"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
}

declare class DialogService {
    private readonly defaultConfirmationOptions;
    private readonly translate;
    private readonly dialog;
    showDialog(title: string, message: string): Promise<any>;
    showCustomDialog(component: ComponentType<unknown>, args: any, options?: any): Promise<any>;
    askForConfirmation(title: string, message: string, args?: Partial<ConfirmationOptions>, options?: any): Promise<ConfirmationResult>;
    askForDeleteConfirmation(name: string, type: string, translateType?: boolean): Promise<any>;
    showDeletionError(name: string): Promise<any>;
    input(inputOptions: InputOptions, optionsDialog?: any, value?: string, suffix?: string): Promise<{
        result: ConfirmationResult;
        value: string;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}
interface ConfirmationOptions {
    noText: string;
    noColor: string;
    noType?: 'basic' | 'raised' | 'stroked' | 'flat' | 'icon';
    yesText: string;
    yesColor: string;
    yesType?: 'basic' | 'raised' | 'stroked' | 'flat' | 'icon';
    messageArgs: any;
    titleArgs: any;
}
declare enum ConfirmationResult {
    Cancel = 0,
    Yes = 1,
    No = 2
}
interface InputOptions {
    titleLabel: string;
    validateButtonLabel: string;
    cancelButtonLabel: string;
    inputLabel: string;
    useTextArea?: boolean;
    validators?: ValidatorFn | ValidatorFn[];
}

declare class LoadingStateService {
    showLoadingIndicator: Signal<boolean>;
    showError: Signal<boolean>;
    private readonly isLoading;
    private readonly hasError;
    showLoading(): void;
    hideLoading(): void;
    withLoadingIndicator<T>(observable$: Observable<T>): Observable<T>;
    private startLoading;
    private handleError;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingStateService>;
}

declare class LoadingErrorComponent {
    retryRequest: EventEmitter<void>;
    readonly loadingState: LoadingStateService;
    showError: i0.Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingErrorComponent, "cauca-loading-error", never, {}, { "retryRequest": "retryRequest"; }, never, never, true, never>;
}

declare class LoadingSpinnerIndicatorComponent {
    diameter: InputSignal<number>;
    loadingState: LoadingStateService;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingSpinnerIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingSpinnerIndicatorComponent, "cauca-loading-spinner-indicator", never, { "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SnackBarComponent {
    icon: InputSignal<string>;
    caption: InputSignal<string>;
    showCloseButton: InputSignal<boolean>;
    type: InputSignal<'info' | 'success' | 'warning' | 'error'>;
    variant: InputSignal<'filled' | 'outlined' | 'standard'>;
    appearanceClasses: Signal<("error" | "info" | "success" | "warning" | "filled" | "outlined" | "standard")[]>;
    buttonSpecificColor: InputSignal<string>;
    buttonIcon: InputSignal<string>;
    inProgress: InputSignal<boolean>;
    showButton: InputSignal<boolean>;
    buttonLabel: InputSignal<string>;
    buttonColor: Signal<string>;
    closeClick: EventEmitter<void>;
    buttonClick: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SnackBarComponent, "cauca-snackbar", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "buttonSpecificColor": { "alias": "buttonSpecificColor"; "required": false; "isSignal": true; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; "isSignal": true; }; "inProgress": { "alias": "inProgress"; "required": false; "isSignal": true; }; "showButton": { "alias": "showButton"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; }, { "closeClick": "closeClick"; "buttonClick": "buttonClick"; }, never, ["*"], true, never>;
}

declare class BadgeComponent {
    icon: i0.InputSignal<string>;
    label: i0.InputSignal<string>;
    color: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "cauca-badge", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IconComponent {
    isFontAwesome: boolean;
    faIcon: string[];
    image: string;
    set icon(value: string);
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "cauca-icon", never, { "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListPaginatorComponent {
    itemsCount: InputSignal<number>;
    showTotalPage: InputSignal<number>;
    pageSize: InputSignal<number>;
    pageCount: Signal<number>;
    pages: Signal<number[]>;
    currentPage: WritableSignal<number>;
    previousDisabled: Signal<boolean>;
    nextDisabled: Signal<boolean>;
    pagesToShow: Signal<number[]>;
    pageChange: EventEmitter<number>;
    get pageSplitter(): string;
    get pageSplitterValue(): number;
    changePage(page: number): void;
    moveToFirst(): void;
    tryMoveToFirst(): void;
    tryMoveToLast(): void;
    tryMoveToPrevious(): void;
    tryMoveToNext(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListPaginatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListPaginatorComponent, "cauca-list-paginator", never, { "itemsCount": { "alias": "itemsCount"; "required": false; "isSignal": true; }; "showTotalPage": { "alias": "showTotalPage"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
}

declare class PasswordValidation {
    hasMinimumCharacters: boolean;
    hasMinimumNumeric: boolean;
    hasLowerAndUppercase: boolean;
    hasSpecialCharacter: boolean;
    hasIdenticalPassword: boolean;
    constructor(hasMinimumCharacters?: boolean, hasMinimumNumeric?: boolean, hasLowerAndUppercase?: boolean, hasSpecialCharacter?: boolean, hasIdenticalPassword?: boolean);
    isValid(): boolean;
}

declare class PasswordCriteriaViewerComponent {
    passwordValidation: InputSignal<PasswordValidation>;
    disabled: InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordCriteriaViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordCriteriaViewerComponent, "cauca-password-criteria-viewer", never, { "passwordValidation": { "alias": "passwordValidation"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PasswordSelectionComponent implements ControlValueAccessor {
    form: UntypedFormGroup;
    passwordValidation: PasswordValidation;
    disabled: boolean;
    direction: 'row' | 'column';
    formWidth: string;
    showCriteriaOnlyWhenPasswordHasValue: i0.InputSignal<boolean>;
    alwaysShowCriteria: i0.InputSignal<boolean>;
    showCriteria: i0.WritableSignal<boolean>;
    passwordLabel: i0.InputSignal<string>;
    passwordConfirmationLabel: i0.InputSignal<string>;
    hasValueChange: i0.OutputEmitterRef<boolean>;
    private lastPasswordValidationSent;
    constructor(formBuilder: UntypedFormBuilder);
    writeValue(value: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onChange: (value: string) => string;
    onTouched: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordSelectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordSelectionComponent, "cauca-password-selection", never, { "direction": { "alias": "direction"; "required": false; }; "formWidth": { "alias": "formWidth"; "required": false; }; "showCriteriaOnlyWhenPasswordHasValue": { "alias": "showCriteriaOnlyWhenPasswordHasValue"; "required": false; "isSignal": true; }; "alwaysShowCriteria": { "alias": "alwaysShowCriteria"; "required": false; "isSignal": true; }; "passwordLabel": { "alias": "passwordLabel"; "required": false; "isSignal": true; }; "passwordConfirmationLabel": { "alias": "passwordConfirmationLabel"; "required": false; "isSignal": true; }; }, { "hasValueChange": "hasValueChange"; }, never, ["*"], true, never>;
}

declare class PasswordInputComponent implements ControlValueAccessor {
    autocomplete: InputSignal<string>;
    translateLabel: InputSignal<boolean>;
    label: InputSignal<string>;
    translatePlaceholder: InputSignal<boolean>;
    placeholder: InputSignal<string>;
    required: InputSignal<boolean>;
    enterKeyDown: i0.OutputEmitterRef<void>;
    passwordControl: FormControl;
    disabled: WritableSignal<boolean>;
    showPassword: WritableSignal<boolean>;
    inputType: i0.Signal<"password" | "text">;
    constructor();
    writeValue(value: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onChange: (value: string) => string;
    onTouched: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordInputComponent, "cauca-password-input", never, { "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "translateLabel": { "alias": "translateLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "translatePlaceholder": { "alias": "translatePlaceholder"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "enterKeyDown": "enterKeyDown"; }, never, never, true, never>;
}

declare class DateRangePickerComponent implements OnInit {
    range: i0.ModelSignal<DateRange>;
    readonly form: FormGroup<{
        from: FormControl<any>;
        to: FormControl<any>;
    }>;
    constructor();
    ngOnInit(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangePickerComponent, "cauca-date-range-picker", never, { "range": { "alias": "range"; "required": false; "isSignal": true; }; }, { "range": "rangeChange"; }, never, never, true, never>;
}
interface DateRange {
    from: Date | null;
    to: Date | null;
}

declare class DropdownChipAutocompleteComponent implements ControlValueAccessor, MatFormFieldControl<any[]>, OnDestroy, DoCheck {
    ngControl: NgControl;
    private readonly parentForm;
    private readonly parentFormGroup;
    private readonly elementRef;
    id: string;
    matAutocomplete: MatAutocomplete;
    matChipInput: ElementRef<HTMLInputElement>;
    matAutocompletePanel: MatAutocompleteTrigger;
    clearAll: EventEmitter<void>;
    listAutoComplete: object[];
    keyValue: string;
    displayValue: string;
    allowRemove: boolean;
    ariaDescribedBy: string;
    canRemoveAll: i0.InputSignal<boolean>;
    hasOptionTemplate: i0.InputSignal<boolean>;
    optionTemplate: TemplateRef<any>;
    stateChanges: Subject<void>;
    static nextId: number;
    focused: boolean;
    touched: boolean;
    errorState: boolean;
    controlType: string;
    separatorKeysCodes: any;
    filteredListAutoComplete: Observable<object[]>;
    private _required;
    private _disabled;
    private _placeholder;
    private _searchValue;
    private selectedValues;
    get searchValue(): string;
    set searchValue(newValue: string);
    get shouldLabelFloat(): boolean;
    get value(): any[];
    set value(values: any[]);
    get required(): boolean;
    set required(req: BooleanInput);
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    get empty(): boolean;
    get placeholder(): string;
    set placeholder(plh: string);
    constructor(ngControl: NgControl, parentForm: NgForm, parentFormGroup: FormGroupDirective, elementRef: ElementRef<HTMLElement>);
    ngDoCheck(): void;
    ngOnDestroy(): void;
    onChange: (_: any) => void;
    onTouched: () => void;
    onFocusIn(): void;
    markAsClean(): void;
    onFocusOut(event: FocusEvent): void;
    setDisabledState(isDisabled: boolean): void;
    setDescribedByIds(ids: string[]): void;
    onContainerClick(event: MouseEvent): void;
    writeValue(value: string[] | []): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    selectItemOnAutocomplete(e: MatAutocompleteSelectedEvent): void;
    removeSelectedItem(key: any): void;
    getValueDisplay(key: any): string;
    onClearAll(): void;
    private updateErrorState;
    private filterSelectedItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownChipAutocompleteComponent, [{ optional: true; self: true; }, { optional: true; }, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownChipAutocompleteComponent, "cauca-dropdown-chip-autocomplete", never, { "listAutoComplete": { "alias": "listAutoComplete"; "required": false; }; "keyValue": { "alias": "keyValue"; "required": false; }; "displayValue": { "alias": "displayValue"; "required": false; }; "allowRemove": { "alias": "allowRemove"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "canRemoveAll": { "alias": "canRemoveAll"; "required": false; "isSignal": true; }; "hasOptionTemplate": { "alias": "hasOptionTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "clearAll": "clearAll"; }, ["optionTemplate"], never, true, never>;
}

declare class GroupContainerComponent {
    caption: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GroupContainerComponent, "cauca-group-container", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class MainSectionComponent {
    title: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MainSectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MainSectionComponent, "cauca-main-section", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SectionColumnComponent {
    showBigGap: i0.InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SectionColumnComponent, "cauca-section-column", never, { "showBigGap": { "alias": "showBigGap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SectionFieldComponent {
    autoTranslateLabel: i0.InputSignal<boolean>;
    label: i0.InputSignal<string>;
    value: i0.InputSignal<unknown>;
    values: i0.InputSignal<unknown[]>;
    fieldName: i0.InputSignal<string>;
    useMultipleValues: i0.Signal<boolean>;
    showLink: i0.InputSignal<boolean>;
    linkClick: i0.OutputEmitterRef<void>;
    splitEqually: i0.InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SectionFieldComponent, "cauca-section-field", never, { "autoTranslateLabel": { "alias": "autoTranslateLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "fieldName": { "alias": "fieldName"; "required": false; "isSignal": true; }; "showLink": { "alias": "showLink"; "required": false; "isSignal": true; }; "splitEqually": { "alias": "splitEqually"; "required": false; "isSignal": true; }; }, { "linkClick": "linkClick"; }, never, never, true, never>;
}

declare class BreadcrumbLocation {
    link?: string;
    title: string;
    translate?: boolean;
    action?: () => void;
}

declare class PageTitleComponent {
    caption: i0.InputSignal<string>;
    showBreadcrumb: i0.InputSignal<boolean>;
    location: i0.InputSignal<BreadcrumbLocation[]>;
    breadcrumb: i0.InputSignal<string>;
    baseCrumb: i0.InputSignal<string>;
    translateBreadcrumb: i0.InputSignal<boolean>;
    displayBreadcrumb: i0.Signal<boolean>;
    breadcrumbLocation: i0.Signal<BreadcrumbLocation[]>;
    currentBreadcrumb: i0.Signal<string>;
    mustTranslateBreadcrumb: i0.Signal<boolean>;
    private readonly breadcrumbService;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageTitleComponent, "cauca-page-title", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "showBreadcrumb": { "alias": "showBreadcrumb"; "required": false; "isSignal": true; }; "location": { "alias": "location"; "required": false; "isSignal": true; }; "breadcrumb": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; "baseCrumb": { "alias": "baseCrumb"; "required": false; "isSignal": true; }; "translateBreadcrumb": { "alias": "translateBreadcrumb"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SavingConfirmedBoxComponent {
    show: i0.ModelSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SavingConfirmedBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SavingConfirmedBoxComponent, "cauca-saving-confirmed-box", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; }, { "show": "showChange"; }, never, never, true, never>;
}

declare class SavingErrorBoxComponent {
    show: i0.ModelSignal<boolean>;
    specificError: i0.InputSignal<string>;
    error: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SavingErrorBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SavingErrorBoxComponent, "cauca-saving-error-box", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "specificError": { "alias": "specificError"; "required": false; "isSignal": true; }; }, { "show": "showChange"; }, never, never, true, never>;
}

declare class AutoTrimAndLowerDirective {
    private readonly el;
    constructor(el: ElementRef);
    onBlur(_: KeyboardEvent): void;
    private trimText;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoTrimAndLowerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoTrimAndLowerDirective, "[appAutoTrimAndLower]", never, {}, {}, never, never, true, never>;
}

declare class HasErrorRootDirective {
    private readonly _formControl$;
    set formControl(formControlDirective: FormControlDirective);
    set formControlName(formControlName: FormControlName);
    get formControl$(): rxjs.Observable<FormControl<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HasErrorRootDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HasErrorRootDirective, "mat-form-field", never, {}, {}, ["formControl", "formControlName"], never, false, never>;
}

interface HasErrorContext {
    $implicit: any;
}
declare class HasErrorDirective implements AfterContentInit, OnDestroy {
    private readonly hasErrorRoot;
    private readonly templateRef;
    private readonly vcr;
    private readonly errorName$;
    private readonly ctrl$;
    private readonly status$;
    private readonly error$;
    private view?;
    private subscription?;
    set hasError(errorName: string);
    constructor(hasErrorRoot: HasErrorRootDirective, templateRef: TemplateRef<HasErrorContext>, vcr: ViewContainerRef);
    static ngTemplateContextGuard(_dir: HasErrorDirective, ctx: unknown): ctx is HasErrorContext;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HasErrorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HasErrorDirective, "[hasError]", never, { "hasError": { "alias": "hasError"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FormErrorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormErrorModule, [typeof HasErrorDirective, typeof HasErrorRootDirective], [typeof i3.CommonModule, typeof i4.ReactiveFormsModule], [typeof HasErrorDirective, typeof HasErrorRootDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormErrorModule>;
}

declare class CaucaInputFileComponent implements OnInit {
    file: ElementRef;
    readend: EventEmitter<any>;
    accept: string;
    multiple: boolean;
    icon: string;
    text: string;
    private labels;
    private readonly translateService;
    private readonly dialog;
    ngOnInit(): void;
    onSelectFile(e: any): void;
    openDialog(event: any): void;
    private onError;
    private onReadEnd;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaInputFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaInputFileComponent, "cauca-input-file", never, { "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "readend": "readend"; }, never, never, true, never>;
}

declare class CaucaInputMultipleLangueComponent implements OnInit {
    value: string[];
    config: Configuration;
    forms: UntypedFormControl[];
    labels: string[];
    selectedIndex: number;
    private readonly translate;
    constructor();
    ngOnInit(): void;
    onTagChanged(tabIndex: number): void;
    getErrorMessage(index: any): string;
    private initializeForms;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaInputMultipleLangueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaInputMultipleLangueComponent, "cauca-input-multiple-langue", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MenuItem {
    label: string;
    path: string;
    icon: string | string[];
    activated: boolean;
    childs: MenuItem[];
    constructor(label: string, path: string, icon?: string | string[]);
}

declare class CaucaMenuSidebarComponent {
    menuItems: MenuItem[];
    version: string;
    private hostElement;
    private keepMenuExpanded;
    constructor();
    onResize(_e: any): void;
    onMenuItemClick(): void;
    hideOnMobile(): void;
    showOnMobile(): void;
    onToggleCollapse(): void;
    private setDisplayMenu;
    private onMouseOver;
    private onMouseOut;
    private onExpandedMenu;
    private onCollapseMenu;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaMenuSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaMenuSidebarComponent, "cauca-menu-sidebar", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "version": { "alias": "version"; "required": false; }; }, {}, never, ["[header]", "[beforeMenu]", "[afterMenu]", "[footer]"], true, never>;
}

declare class CaucaMenuVerticalComponent {
    itemClick: EventEmitter<any>;
    menuItems: MenuItem[];
    private readonly router;
    constructor();
    goTo(path: string, e: any): void;
    private selectActiveRoute;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaMenuVerticalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaMenuVerticalComponent, "cauca-menu-vertical", never, { "menuItems": { "alias": "menuItems"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
}

declare class SimpleDialogData {
    title: string;
    message: string;
    buttons: string[];
}

declare class CaucaSimpleDialogComponent {
    readonly data: SimpleDialogData;
    private readonly dialogRef;
    onClick(buttonIndex: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaSimpleDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaSimpleDialogComponent, "cauca-simple-dialog", never, {}, {}, never, never, true, never>;
}

declare class CaucaSlideshowComponent implements OnInit {
    container: ElementRef;
    height: string;
    autoPlay: boolean;
    private timer;
    private items;
    private states;
    private selectedIndex;
    set images(list: string[]);
    get images(): string[];
    ngOnInit(): void;
    getState(index: number): string;
    restart(): void;
    next(): void;
    private changed;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaucaSlideshowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaucaSlideshowComponent, "cauca-slideshow", never, { "height": { "alias": "height"; "required": false; }; "autoPlay": { "alias": "autoPlay"; "required": false; }; "images": { "alias": "images"; "required": false; }; }, {}, never, never, true, never>;
}

export { AutoTrimAndLowerDirective, BadgeComponent, BasicButtonComponent, ButtonComponent, CaucaDateTimePickerComponent, CaucaInputFileComponent, CaucaInputMultipleLangueComponent, CaucaMaterialComponent, CaucaMaterialService, CaucaMenuSidebarComponent, CaucaMenuVerticalComponent, CaucaSimpleDialogComponent, CaucaSlideshowComponent, ConfirmationResult, DateRangePickerComponent, DialogService, DropdownChipAutocompleteComponent, FabButtonComponent, FlatButtonComponent, FormErrorModule, GroupContainerComponent, HasErrorDirective, HasErrorRootDirective, IconButtonComponent, IconComponent, LinkButtonComponent, ListPaginatorComponent, LoadingErrorComponent, LoadingSpinnerIndicatorComponent, LoadingStateService, MainSectionComponent, MenuItem, MenuItemComponent, PageTitleComponent, PasswordCriteriaViewerComponent, PasswordInputComponent, PasswordSelectionComponent, RaisedButtonComponent, RefreshButtonComponent, RoundButtonComponent, SavingConfirmedBoxComponent, SavingErrorBoxComponent, SectionColumnComponent, SectionFieldComponent, SnackBarComponent, StrokedButtonComponent };
export type { ConfirmationOptions, DateRange, HasErrorContext, InputOptions };