import * as _angular_core from '@angular/core';
import { OnInit, InputSignal, OutputEmitterRef, Signal, WritableSignal, OnDestroy, DoCheck, ElementRef, TemplateRef, AfterViewInit, ModelSignal, AfterContentInit, ViewContainerRef, PipeTransform, Type, Provider, EnvironmentProviders, EventEmitter } from '@angular/core';
import * as i4 from '@angular/forms';
import { ControlValueAccessor, AbstractControl, ValidatorFn, FormGroup, UntypedFormGroup, FormControl, NgControl, FormControlDirective, FormControlName, UntypedFormControl } from '@angular/forms';
import { SubscriptSizing, MatFormFieldControl } from '@angular/material/form-field';
import { ComponentType } from '@angular/cdk/portal';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { MaybeAsync, CanDeactivateFn } from '@angular/router';
import { BooleanInput } from '@angular/cdk/coercion';
import { MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import { MatSelect } from '@angular/material/select';
import * as i3 from '@angular/common';
import { Configuration } from '@cauca-911/core';

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

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

declare class CaucaDateTimePickerComponent implements ControlValueAccessor, OnInit {
    readonly value: _angular_core.ModelSignal<Date>;
    readonly subscriptSizing: _angular_core.InputSignal<SubscriptSizing>;
    readonly showTime: _angular_core.InputSignal<boolean>;
    readonly label: _angular_core.InputSignal<string>;
    readonly translateLabel: _angular_core.InputSignal<boolean>;
    readonly stepHours: _angular_core.InputSignal<number>;
    readonly stepMinutes: _angular_core.InputSignal<number>;
    readonly stepSecondes: _angular_core.InputSignal<number>;
    readonly minimumDate: _angular_core.InputSignal<Date>;
    readonly maximumDate: _angular_core.InputSignal<Date>;
    readonly showSeconds: _angular_core.InputSignal<boolean>;
    readonly showFormat: _angular_core.InputSignal<string>;
    readonly showClearButton: _angular_core.InputSignal<boolean>;
    readonly showButtonIcons: _angular_core.InputSignal<boolean>;
    readonly selectedChange: _angular_core.OutputEmitterRef<Date>;
    control: AbstractControl;
    readonly stringDate: _angular_core.Signal<string>;
    readonly isRequired: _angular_core.Signal<boolean>;
    private readonly injector;
    private readonly elementRef;
    private readonly dialog;
    private readonly datePipe;
    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: _angular_core.ɵɵFactoryDeclaration<CaucaDateTimePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CaucaDateTimePickerComponent, "cauca-date-time-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "translateLabel": { "alias": "translateLabel"; "required": false; "isSignal": true; }; "stepHours": { "alias": "stepHours"; "required": false; "isSignal": true; }; "stepMinutes": { "alias": "stepMinutes"; "required": false; "isSignal": true; }; "stepSecondes": { "alias": "stepSecondes"; "required": false; "isSignal": true; }; "minimumDate": { "alias": "minimumDate"; "required": false; "isSignal": true; }; "maximumDate": { "alias": "maximumDate"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "showFormat": { "alias": "showFormat"; "required": false; "isSignal": true; }; "showClearButton": { "alias": "showClearButton"; "required": false; "isSignal": true; }; "showButtonIcons": { "alias": "showButtonIcons"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "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: _angular_core.Signal<string>;
    showIcon: _angular_core.Signal<boolean>;
    iconToShow: _angular_core.Signal<string>;
    buttonDisabled: _angular_core.Signal<boolean>;
    buttonClick: OutputEmitterRef<void>;
    isHovered: _angular_core.WritableSignal<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseButton, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<BaseButtonWithLabel, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<BasicButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BasicButtonComponent, "cauca-basic-button", never, {}, {}, never, never, true, never>;
}

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

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

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

declare class LinkButtonComponent {
    readonly segments: _angular_core.InputSignal<string[]>;
    private readonly clipboard;
    copyLink(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<RaisedButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RaisedButtonComponent, "cauca-raised-button", never, {}, {}, never, never, true, never>;
}

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

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

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

declare class ButtonComponent {
    class: _angular_core.InputSignal<string>;
    inProgress: _angular_core.InputSignal<boolean>;
    disable: _angular_core.InputSignal<boolean>;
    label: _angular_core.InputSignal<string>;
    icon: _angular_core.InputSignal<string>;
    color: _angular_core.InputSignal<string>;
    type: _angular_core.InputSignal<"flat" | "basic" | "raised" | "stroked" | "icon" | "fab">;
    buttonClick: _angular_core.OutputEmitterRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "cauca-button", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "inProgress": { "alias": "inProgress"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "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: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: _angular_core.ɵɵ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 BreadcrumbLocation {
    link?: string;
    title: string;
    translate?: boolean;
    action?: () => void;
}

declare class BreadcrumbService {
    showBreadcrumb: Signal<boolean>;
    location: WritableSignal<BreadcrumbLocation[]>;
    breadcrumb: WritableSignal<string>;
    translateBreadcrumb: WritableSignal<boolean>;
    private readonly isShown;
    show(breadcrumb: string, location?: BreadcrumbLocation[], translateBreadcrumb?: boolean): void;
    hide(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BreadcrumbService>;
}

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>;
    setAsInError(): void;
    private startLoading;
    private handleError;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoadingStateService>;
}

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

declare class LoadingSpinnerIndicatorComponent {
    diameter: InputSignal<number>;
    loadingState: LoadingStateService;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingSpinnerIndicatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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>;
    readonly closeClick: _angular_core.OutputEmitterRef<void>;
    readonly buttonClick: _angular_core.OutputEmitterRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnackBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.InputSignal<string>;
    label: _angular_core.InputSignal<string>;
    color: _angular_core.InputSignal<string>;
    customColor: _angular_core.InputSignal<string>;
    customTextColor: _angular_core.InputSignal<string>;
    textTransform: _angular_core.InputSignal<"capitalize" | "uppercase" | "lowercase">;
    autoTranslate: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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; }; "customColor": { "alias": "customColor"; "required": false; "isSignal": true; }; "customTextColor": { "alias": "customTextColor"; "required": false; "isSignal": true; }; "textTransform": { "alias": "textTransform"; "required": false; "isSignal": true; }; "autoTranslate": { "alias": "autoTranslate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IconComponent {
    readonly icon: _angular_core.InputSignal<string>;
    readonly isFontAwesome: _angular_core.Signal<boolean>;
    readonly faIcon: _angular_core.Signal<string[]>;
    readonly image: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "cauca-icon", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface ReleaseNoteDetailForDisplay {
    id: string;
    description: string;
    detailType: ReleaseNoteDetailForDisplay;
    hasUpVoted: boolean;
    canVote: boolean;
    upVoteCount: number;
    downVoteCount: number;
}

interface ReleaseNoteForDisplay {
    id: string;
    version: string;
    releasedOn: Date;
    bugFixesWeb: ReleaseNoteDetailForDisplay[];
    newFeaturesWeb: ReleaseNoteDetailForDisplay[];
    bugFixesMobile: ReleaseNoteDetailForDisplay[];
    newFeaturesMobile: ReleaseNoteDetailForDisplay[];
    showBugFixesWeb: boolean;
    showNewFeaturesWeb: boolean;
    showBugFixesMobile: boolean;
    showNewFeaturesMobile: boolean;
}

declare abstract class PermissionStateForReleaseNotes {
    abstract canManageReleaseNotes: Signal<boolean>;
}

declare class ReleaseNotesComponent implements OnInit {
    releaseNotes$: Observable<ReleaseNoteForDisplay[]>;
    readonly userPermissionStateService: PermissionStateForReleaseNotes;
    private readonly releaseNotesService;
    private readonly router;
    ngOnInit(): void;
    setObservable(): void;
    openNewReleaseNote(): Promise<void>;
    refreshReleaseNote(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReleaseNotesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReleaseNotesComponent, "cauca-release-notes", never, {}, {}, never, never, true, never>;
}

interface OnDeactivate {
    canDeactivate: () => MaybeAsync<boolean>;
}
declare const pendingChangesGuard: CanDeactivateFn<OnDeactivate>;

declare class ReleaseNoteEditionPageComponent implements OnInit, OnDeactivate {
    form: FormGroup;
    id: InputSignal<string>;
    isLoaded: WritableSignal<boolean>;
    isSaving: WritableSignal<boolean>;
    showSavingError: WritableSignal<boolean>;
    caption: _angular_core.Signal<"releaseNotes.newReleaseTitle" | "releaseNotes.modificationTitle">;
    private readonly state;
    private readonly dialog;
    private router;
    private isClosing;
    ngOnInit(): void;
    canDeactivate(): Promise<boolean>;
    loadData(): Promise<void>;
    cancel(): Promise<void>;
    save(): Promise<void>;
    protected onBeforeUnload(e: BeforeUnloadEvent): Promise<void>;
    private tryToSave;
    private canCancel;
    private askForCancelConfirmation;
    private showValidationError;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReleaseNoteEditionPageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReleaseNoteEditionPageComponent, "cauca-release-note-edition-page", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function computeFittablePageCount(availableWidth: number): number;
declare class ListPaginatorComponent implements OnInit {
    itemsCount: InputSignal<number>;
    showTotalPage: InputSignal<number>;
    pageSize: InputSignal<number>;
    pageCount: Signal<number>;
    currentPage: WritableSignal<number>;
    previousDisabled: Signal<boolean>;
    nextDisabled: Signal<boolean>;
    readonly collapsedToCurrentOnly: Signal<boolean>;
    pagesToShow: Signal<number[]>;
    readonly pageChange: _angular_core.OutputEmitterRef<number>;
    private readonly elementRef;
    private readonly destroyRef;
    private readonly fittablePageCount;
    get pageSplitter(): string;
    get pageSplitterValue(): number;
    ngOnInit(): void;
    changePage(page: number): void;
    moveToFirst(): void;
    tryMoveToFirst(): void;
    tryMoveToLast(): void;
    tryMoveToPrevious(): void;
    tryMoveToNext(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPaginatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<PasswordCriteriaViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.WritableSignal<boolean>;
    readonly direction: _angular_core.InputSignal<"row" | "column">;
    readonly formWidth: _angular_core.InputSignal<string>;
    showCriteriaOnlyWhenPasswordHasValue: _angular_core.InputSignal<boolean>;
    alwaysShowCriteria: _angular_core.InputSignal<boolean>;
    showCriteria: _angular_core.WritableSignal<boolean>;
    passwordLabel: _angular_core.InputSignal<string>;
    passwordConfirmationLabel: _angular_core.InputSignal<string>;
    hasValueChange: _angular_core.OutputEmitterRef<boolean>;
    private lastPasswordValidationSent;
    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: _angular_core.ɵɵFactoryDeclaration<PasswordSelectionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordSelectionComponent, "cauca-password-selection", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "formWidth": { "alias": "formWidth"; "required": false; "isSignal": true; }; "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: _angular_core.OutputEmitterRef<void>;
    passwordControl: FormControl;
    disabled: WritableSignal<boolean>;
    showPassword: WritableSignal<boolean>;
    inputType: _angular_core.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: _angular_core.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ModelSignal<DateRange>;
    readonly form: FormGroup<{
        from: FormControl<any>;
        to: FormControl<any>;
    }>;
    constructor();
    ngOnInit(): void;
    clear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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 {
    id: string;
    matAutocomplete: MatAutocomplete;
    matChipInput: ElementRef<HTMLInputElement>;
    matAutocompletePanel: MatAutocompleteTrigger;
    readonly clearAll: _angular_core.OutputEmitterRef<void>;
    listAutoComplete: _angular_core.InputSignal<object[]>;
    keyValue: _angular_core.InputSignal<string>;
    displayValue: _angular_core.InputSignal<string>;
    allowRemove: _angular_core.InputSignal<boolean>;
    ariaDescribedBy: _angular_core.InputSignal<string>;
    canRemoveAll: _angular_core.InputSignal<boolean>;
    hasOptionTemplate: _angular_core.InputSignal<boolean>;
    optionTemplate: TemplateRef<any>;
    stateChanges: Subject<void>;
    static nextId: number;
    focused: boolean;
    touched: boolean;
    errorState: boolean;
    controlType: string;
    separatorKeysCodes: any;
    filteredListAutoComplete: Observable<object[]>;
    ngControl: NgControl;
    private _required;
    private _disabled;
    private _placeholder;
    private _searchValue;
    private selectedValues;
    private readonly parentForm;
    private readonly parentFormGroup;
    private readonly elementRef;
    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();
    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: _angular_core.ɵɵFactoryDeclaration<DropdownChipAutocompleteComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownChipAutocompleteComponent, "cauca-dropdown-chip-autocomplete", never, { "listAutoComplete": { "alias": "listAutoComplete"; "required": false; "isSignal": true; }; "keyValue": { "alias": "keyValue"; "required": false; "isSignal": true; }; "displayValue": { "alias": "displayValue"; "required": false; "isSignal": true; }; "allowRemove": { "alias": "allowRemove"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "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 ColorPickerComponent implements ControlValueAccessor, MatFormFieldControl<string>, OnDestroy {
    stateChanges: Subject<void>;
    static nextId: number;
    id: string;
    placeholder: string;
    focused: boolean;
    touched: boolean;
    required: boolean;
    disabled: boolean;
    errorState: boolean;
    controlType?: string;
    autofilled?: boolean;
    userAriaDescribedBy?: string;
    readonly valueChanged: _angular_core.OutputEmitterRef<string>;
    ngControl: NgControl;
    private readonly elementRef;
    private _value;
    get shouldLabelFloat(): boolean;
    get empty(): boolean;
    get value(): string | null;
    set value(newValue: string | null);
    constructor();
    onFocusIn(_: FocusEvent): void;
    onFocusOut(event: FocusEvent): void;
    ngOnDestroy(): void;
    setDescribedByIds(_: string[]): void;
    onContainerClick(_: MouseEvent): void;
    writeValue(value: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onChange: (_: any) => void;
    onTouched: () => void;
    onChangeColor(color: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "cauca-color-picker", never, {}, { "valueChanged": "valueChanged"; }, never, never, true, never>;
}

interface Option {
    id: string | null;
    name: string;
}
declare class SelectWithSearchComponent {
    readonly label: _angular_core.InputSignal<string>;
    readonly selectFirstOptionByDefault: _angular_core.InputSignal<boolean>;
    readonly isDisabled: _angular_core.InputSignal<boolean>;
    readonly allowMultiSelection: _angular_core.InputSignal<boolean>;
    readonly showClearOption: _angular_core.InputSignal<boolean>;
    readonly enableSearch: _angular_core.InputSignal<boolean>;
    readonly options: _angular_core.InputSignal<Option[]>;
    readonly value: _angular_core.ModelSignal<string>;
    readonly valueChanged: _angular_core.OutputEmitterRef<string>;
    readonly optionFilterControl: FormControl<string>;
    singleSelect: MatSelect;
    readonly hasOptions: _angular_core.Signal<boolean>;
    readonly disableControl: _angular_core.Signal<boolean>;
    readonly filteredOptions: _angular_core.ResourceRef<Option[]>;
    private readonly filterText;
    constructor();
    onSelectionChange(newValue: string | null): void;
    private selectFirstOption;
    private computeFilteredOptions;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectWithSearchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectWithSearchComponent, "cauca-select-with-search", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "selectFirstOptionByDefault": { "alias": "selectFirstOptionByDefault"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "allowMultiSelection": { "alias": "allowMultiSelection"; "required": false; "isSignal": true; }; "showClearOption": { "alias": "showClearOption"; "required": false; "isSignal": true; }; "enableSearch": { "alias": "enableSearch"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChanged": "valueChanged"; }, never, ["*"], true, never>;
}

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

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

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

declare class SectionFieldComponent {
    autoTranslateCaption: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    value: _angular_core.InputSignal<unknown>;
    values: _angular_core.InputSignal<unknown[]>;
    fieldName: _angular_core.InputSignal<string>;
    useMultipleValues: _angular_core.Signal<boolean>;
    showLink: _angular_core.InputSignal<boolean>;
    linkClick: _angular_core.OutputEmitterRef<void>;
    splitEqually: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SectionFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SectionFieldComponent, "cauca-section-field", never, { "autoTranslateCaption": { "alias": "autoTranslateCaption"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "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 PageTitleComponent {
    caption: _angular_core.InputSignal<string>;
    showBreadcrumb: _angular_core.InputSignal<boolean>;
    location: _angular_core.InputSignal<BreadcrumbLocation[]>;
    breadcrumb: _angular_core.InputSignal<string>;
    baseCrumb: _angular_core.InputSignal<string>;
    translateBreadcrumb: _angular_core.InputSignal<boolean>;
    isMobile: _angular_core.InputSignal<boolean>;
    displayBreadcrumb: _angular_core.Signal<boolean>;
    breadcrumbLocation: _angular_core.Signal<BreadcrumbLocation[]>;
    currentBreadcrumb: _angular_core.Signal<string>;
    mustTranslateBreadcrumb: _angular_core.Signal<boolean>;
    hasBreadcrumb: _angular_core.Signal<boolean>;
    hasLinkedBreadcrumb: _angular_core.Signal<boolean>;
    displayCompactBreadcrumb: _angular_core.Signal<boolean>;
    private readonly breadcrumbService;
    private readonly router;
    backToLastBreadcrumbLink(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageTitleComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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; }; "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ResponsiveTabGroupWrapperComponent implements AfterViewInit {
    readonly mobile: _angular_core.InputSignal<boolean>;
    private readonly destroyRef;
    private readonly elementRef;
    private readonly tabGroup;
    private readonly tabs;
    private readonly swipeThreshold;
    private readonly swipePreviewThreshold;
    private readonly swipePreviewMaxOffsetPx;
    private touchStartX;
    private touchStartY;
    private previousSelectedIndex;
    ngAfterViewInit(): void;
    onWindowResize(): void;
    onTouchStart(event: TouchEvent): void;
    onTouchMove(event: TouchEvent): void;
    onTouchEnd(event: TouchEvent): void;
    onTouchCancel(): void;
    private subscribeToSelectedIndexChanges;
    private goToNextTab;
    private goToPreviousTab;
    private resetTouchState;
    private bindHeaderPaginationControls;
    private handleHeaderPaginationPointerDown;
    private syncHeaderPaginationState;
    private scheduleHeaderPaginationStateSync;
    private setHeaderPaginationDisabled;
    private isFirstTabSelected;
    private isLastTabSelected;
    private getTabCount;
    private isSwipeEnabled;
    private isTouchInsideTabBody;
    private getTabGroupElement;
    private applyNavigationDirectionClass;
    private applySwipePreview;
    private clearSwipePreview;
    private getHeaderPaginationButtons;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveTabGroupWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResponsiveTabGroupWrapperComponent, "cauca-responsive-tab-group-wrapper", never, { "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; }, {}, ["tabGroup", "tabs"], ["*"], true, never>;
}

declare class ExpandablePanelComponent {
    isCollapsed: ModelSignal<boolean>;
    caption: InputSignal<string>;
    subCaption: InputSignal<string>;
    contentPosition: InputSignal<"right" | "underCaption">;
    changeState(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpandablePanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpandablePanelComponent, "cauca-expandable-panel", never, { "isCollapsed": { "alias": "isCollapsed"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "subCaption": { "alias": "subCaption"; "required": false; "isSignal": true; }; "contentPosition": { "alias": "contentPosition"; "required": false; "isSignal": true; }; }, { "isCollapsed": "isCollapsedChange"; }, never, ["*"], true, never>;
}

declare class ExpandablePanelAccordionComponent {
    readonly initialOpenIndex: _angular_core.InputSignal<number>;
    private readonly panels;
    private synchronizingPanels;
    constructor();
    private initializePanels;
    private onPanelStateChange;
    private setExpandedPanel;
    private subscribeToPanelStateChanges;
    private supportsAccordionState;
    private readCollapsedState;
    private writeCollapsedState;
    private isModelSignalLike;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpandablePanelAccordionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpandablePanelAccordionComponent, "cauca-expandable-panel-accordion", never, { "initialOpenIndex": { "alias": "initialOpenIndex"; "required": false; "isSignal": true; }; }, {}, ["panels"], ["*"], true, never>;
}

declare class MenuExpandablePanelComponent {
    caption: InputSignal<string>;
    isSubItem: InputSignal<boolean>;
    subCaption: InputSignal<string>;
    menuIcon: InputSignal<string>;
    showExpansionIcon: InputSignal<boolean>;
    addTopBorderRadius: InputSignal<boolean>;
    bottomBorder: InputSignal<boolean>;
    addBottomBorderRadius: InputSignal<boolean>;
    route: InputSignal<string[]>;
    items: InputSignal<{
        icon: string;
        title: string;
        route?: string[];
        action?: () => void;
    }[]>;
    opened: WritableSignal<boolean>;
    private readonly router;
    handleClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuExpandablePanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuExpandablePanelComponent, "cauca-menu-expandable-panel", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "isSubItem": { "alias": "isSubItem"; "required": false; "isSignal": true; }; "subCaption": { "alias": "subCaption"; "required": false; "isSignal": true; }; "menuIcon": { "alias": "menuIcon"; "required": false; "isSignal": true; }; "showExpansionIcon": { "alias": "showExpansionIcon"; "required": false; "isSignal": true; }; "addTopBorderRadius": { "alias": "addTopBorderRadius"; "required": false; "isSignal": true; }; "bottomBorder": { "alias": "bottomBorder"; "required": false; "isSignal": true; }; "addBottomBorderRadius": { "alias": "addBottomBorderRadius"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MenuExpandablePanelItemComponent {
    icon: InputSignal<string>;
    caption: InputSignal<string>;
    route: InputSignal<string[]>;
    isSubItem: InputSignal<boolean>;
    action: InputSignal<() => void | null>;
    private readonly router;
    openRoute(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuExpandablePanelItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuExpandablePanelItemComponent, "cauca-menu-expandable-panel-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "isSubItem": { "alias": "isSubItem"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

declare class SavingErrorBoxComponent {
    show: _angular_core.ModelSignal<boolean>;
    specificError: _angular_core.InputSignal<string>;
    error: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SavingErrorBoxComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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>;
}

type StatusMessageType = 'error' | 'noData' | 'custom';
declare class StatusMessageComponent {
    type: _angular_core.InputSignal<StatusMessageType>;
    textKey: _angular_core.InputSignal<string>;
    icon: _angular_core.InputSignal<string>;
    readonly resolvedTextKey: _angular_core.Signal<string>;
    readonly resolvedIcon: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusMessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusMessageComponent, "cauca-status-message", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "textKey": { "alias": "textKey"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AutoTrimAndLowerDirective {
    private readonly el;
    constructor(el: ElementRef);
    onBlur(_: KeyboardEvent): void;
    private trimText;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoTrimAndLowerDirective, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<HasErrorRootDirective, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<HasErrorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HasErrorDirective, "[hasError]", never, { "hasError": { "alias": "hasError"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class Iso8601TimeSpanPipe implements PipeTransform {
    transform(value: string | null | undefined): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Iso8601TimeSpanPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Iso8601TimeSpanPipe, "Iso8601TimeSpan", true>;
}

interface CaucaMaterialConfig {
    permissionStateForReleaseNotes?: Type<PermissionStateForReleaseNotes> | null;
    releaseNotesUrlPrefix?: string | null;
}
declare function provideCaucaMaterial(config?: CaucaMaterialConfig): (Provider | EnvironmentProviders)[];

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: _angular_core.ɵɵFactoryDeclaration<CaucaInputFileComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<CaucaInputMultipleLangueComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CaucaInputMultipleLangueComponent, "cauca-input-multiple-langue", never, { "value": { "alias": "value"; "required": false; }; }, {}, 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: _angular_core.ɵɵFactoryDeclaration<CaucaSimpleDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CaucaSimpleDialogComponent, "cauca-simple-dialog", never, {}, {}, never, never, true, never>;
}

declare class CaucaSlideshowComponent implements OnInit {
    container: ElementRef;
    height: string;
    autoPlay: boolean;
    states: any[];
    selectedIndex: number;
    private timer;
    private items;
    set images(list: string[]);
    get images(): string[];
    ngOnInit(): void;
    getState(index: number): string;
    restart(): void;
    next(): void;
    private changed;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CaucaSlideshowComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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, BreadcrumbLocation, BreadcrumbService, ButtonComponent, CaucaDateTimePickerComponent, CaucaInputFileComponent, CaucaInputMultipleLangueComponent, CaucaMaterialComponent, CaucaMaterialService, CaucaSimpleDialogComponent, CaucaSlideshowComponent, ColorPickerComponent, ConfirmationResult, DateRangePickerComponent, DialogService, DropdownChipAutocompleteComponent, ExpandablePanelAccordionComponent, ExpandablePanelComponent, FabButtonComponent, FlatButtonComponent, FormErrorModule, GroupContainerComponent, HasErrorDirective, HasErrorRootDirective, IconButtonComponent, IconComponent, Iso8601TimeSpanPipe, LinkButtonComponent, ListPaginatorComponent, LoadingErrorComponent, LoadingSpinnerIndicatorComponent, LoadingStateService, MainSectionComponent, MenuExpandablePanelComponent, MenuExpandablePanelItemComponent, MenuItemComponent, PageTitleComponent, PasswordCriteriaViewerComponent, PasswordInputComponent, PasswordSelectionComponent, PermissionStateForReleaseNotes, RaisedButtonComponent, RefreshButtonComponent, ReleaseNoteEditionPageComponent, ReleaseNotesComponent, ResponsiveTabGroupWrapperComponent, RoundButtonComponent, SavingConfirmedBoxComponent, SavingErrorBoxComponent, SectionColumnComponent, SectionFieldComponent, SelectWithSearchComponent, SnackBarComponent, StatusMessageComponent, StrokedButtonComponent, computeFittablePageCount, pendingChangesGuard, provideCaucaMaterial };
export type { CaucaMaterialConfig, ConfirmationOptions, DateRange, HasErrorContext, InputOptions, OnDeactivate, Option, StatusMessageType };