@coreui/angular-pro/index.d.ts

CoreUI Pro Components Library for Angular

import { IsActiveMatchOptions, UrlTree, Router, NavigationEnd } from '@angular/router';
import * as _angular_core from '@angular/core';
import { ElementRef, TemplateRef, ModuleWithProviders, OnInit, OnDestroy, InputSignal, InputSignalWithTransform, QueryList, AfterViewInit, PipeTransform, AfterContentInit, AfterContentChecked, ModelSignal, ChangeDetectorRef, ViewContainerRef, OutputEmitterRef, EventEmitter, WritableSignal, OnChanges, SimpleChanges, Renderer2, ComponentRef, Injector, NgModuleRef } from '@angular/core';
import { AnimationEvent } from '@angular/animations';
import * as rxjs from 'rxjs';
import { Observable, Subscription, BehaviorSubject } from 'rxjs';
import { FocusableOption, FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
import { ControlValueAccessor, FormGroup, FormControl } from '@angular/forms';
import { BooleanInput as BooleanInput$1, NumberInput as NumberInput$1 } from '@angular/cdk/coercion';
import * as _popperjs_core from '@popperjs/core';
import { Options, Placement } from '@popperjs/core';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';

declare type BooleanInput = string | boolean | null | undefined;
declare type NumberInput = string | number | null | undefined;
type NgCssClass = string | string[] | Set<string> | {
    [klass: string]: any;
};
declare enum BreakpointInfix {
    xs = "xs",
    sm = "sm",
    md = "md",
    lg = "lg",
    xl = "xl",
    xxl = "xxl"
}
type BreakpointInfixStrings = keyof typeof BreakpointInfix;
type Breakpoints = BreakpointInfixStrings | string;
type Sizes = 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | string;
type Colors = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | 'primary-gradient' | 'secondary-gradient' | 'success-gradient' | 'danger-gradient' | 'warning-gradient' | 'info-gradient' | 'dark-gradient' | 'light-gradient' | string;
type BackgroundColors = Colors | 'body' | 'white' | 'transparent';
type Directions = 'down' | 'up' | 'start' | 'end' | '';
type TextColors = Colors | 'primary-emphasis' | 'secondary-emphasis' | 'success-emphasis' | 'danger-emphasis' | 'warning-emphasis' | 'info-emphasis' | 'light-emphasis' | 'body' | 'body-emphasis' | 'body-secondary' | 'body-tertiary' | 'black' | 'black-50' | 'white' | 'white-50' | string;
type Alignment = 'baseline' | 'top' | 'middle' | 'bottom' | 'text-top' | 'text-bottom';
type BadgePositions = 'top-start' | 'top-end' | 'bottom-end' | 'bottom-start' | string | undefined;
type Placements = 'auto' | 'auto-start' | 'auto-end' | 'top-end' | 'top' | 'top-start' | 'bottom-end' | 'bottom' | 'bottom-start' | 'right-start' | 'right' | 'right-end' | 'left-start' | 'left' | 'left-end' | undefined;
type Shapes = 'rounded' | 'rounded-top' | 'rounded-end' | 'rounded-bottom' | 'rounded-start' | 'rounded-circle' | 'rounded-pill' | 'rounded-0' | 'rounded-1' | 'rounded-2' | 'rounded-3' | string;
type Triggers = 'hover' | 'focus' | 'click' | 'focusin';
type Positions = 'fixed' | 'sticky';
type InputType = 'button' | 'color' | 'date' | 'datetime' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week' | 'checkbox' | 'radio';
interface INavLinkProps$1 {
    queryParams?: {
        [k: string]: any;
    };
    fragment?: string;
    queryParamsHandling?: 'merge' | 'preserve' | '' | null;
    preserveFragment?: boolean;
    skipLocationChange?: boolean;
    replaceUrl?: boolean;
    state?: {
        [k: string]: any;
    };
    routerLinkActiveOptions?: {
        exact: boolean;
    } | IsActiveMatchOptions;
    routerLinkActive?: string | string[];
    ariaCurrentWhenActive?: 'page' | 'step' | 'location' | 'date' | 'time' | true | false;
}
interface INavAttributes$1 {
    [propName: string]: any;
}
type ButtonType = 'button' | 'submit' | 'reset';

declare class ElementRefDirective {
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementRefDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ElementRefDirective, "[cElementRef]", ["cElementRef"], {}, {}, never, never, true, never>;
}

declare class HtmlAttributesDirective {
    #private;
    readonly cHtmlAttr: _angular_core.InputSignal<Record<string, any> | undefined>;
    private setStyle;
    private addClass;
    private setAttrib;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HtmlAttributesDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HtmlAttributesDirective, "[cHtmlAttr]", ["cHtmlAttr"], { "cHtmlAttr": { "alias": "cHtmlAttr"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TemplateIdDirective {
    readonly templateRef: TemplateRef<any>;
    readonly cTemplateId: _angular_core.InputSignal<string>;
    get id(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateIdDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TemplateIdDirective, "[cTemplateId]", never, { "cTemplateId": { "alias": "cTemplateId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ThemeDirective {
    #private;
    /**
     * Add dark theme attribute.
     * @return 'dark' | 'light' | undefined
     */
    readonly colorScheme: _angular_core.InputSignal<"dark" | "light" | undefined>;
    readonly dark: _angular_core.InputSignalWithTransform<boolean, unknown>;
    setTheme(theme?: string): void;
    unsetTheme(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThemeDirective, "[cTheme]", ["cTheme"], { "colorScheme": { "alias": "colorScheme"; "required": false; "isSignal": true; }; "dark": { "alias": "dark"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SharedModule {
    static forRoot(): ModuleWithProviders<SharedModule>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SharedModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SharedModule, never, [typeof ElementRefDirective, typeof HtmlAttributesDirective, typeof TemplateIdDirective, typeof ThemeDirective], [typeof ElementRefDirective, typeof HtmlAttributesDirective, typeof TemplateIdDirective, typeof ThemeDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SharedModule>;
}

declare class AccordionButtonDirective {
    /**
     * Toggles an accordion button collapsed state. Use in accordionHeaderTemplate. [docs]
     * @type boolean
     */
    readonly collapsed: _angular_core.InputSignal<boolean | undefined>;
    /**
     * Default type for cAccordionButton. [docs]
     * @type string
     * @default 'button'
     */
    readonly type: _angular_core.InputSignal<string>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    readonly ariaExpanded: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionButtonDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionButtonDirective, "[cAccordionButton]", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AccordionComponent {
    #private;
    /**
     * Removes the default background-color, some borders, and some rounded corners to render accordions edge-to-edge with their parent container.
     * @type boolean
     */
    readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Make accordion items stay open when another item is opened
     * @type boolean
     */
    readonly alwaysOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "c-accordion", ["cAccordionItem"], { "flush": { "alias": "flush"; "required": false; "isSignal": true; }; "alwaysOpen": { "alias": "alwaysOpen"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class AccordionItemComponent implements OnInit, OnDestroy {
    #private;
    /**
     * Toggle an accordion item programmatically
     * @return boolean
     * @default false
     */
    readonly visibleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly itemVisible: _angular_core.WritableSignal<boolean>;
    set visible(value: boolean);
    get visible(): boolean;
    contentId: string;
    get itemContext(): {
        $implicit: boolean;
    };
    readonly contentTemplates: _angular_core.Signal<readonly TemplateIdDirective[]>;
    readonly templates: _angular_core.Signal<Record<string, TemplateRef<any>>>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    toggleItem(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "c-accordion-item", ["cAccordionItem"], { "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, ["contentTemplates"], ["*", "*"], true, never>;
}

declare class AccordionModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof AccordionButtonDirective, typeof AccordionComponent, typeof AccordionItemComponent], [typeof AccordionComponent, typeof AccordionButtonDirective, typeof AccordionItemComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AccordionModule>;
}

declare class AlertHeadingDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertHeadingDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AlertHeadingDirective, "[cAlertHeading]", never, {}, {}, never, never, true, never>;
}

declare class AlertLinkDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertLinkDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AlertLinkDirective, "[cAlertLink]", never, {}, {}, never, never, true, never>;
}

type AnimateType$1 = 'hide' | 'show';
declare class AlertComponent {
    #private;
    /**
     * Sets the color context of the component to one of CoreUI’s themed colors.
     * @return Colors
     * @default 'primary'
     */
    readonly color: _angular_core.InputSignal<string>;
    /**
     * Default role for alert. [docs]
     * @return string
     * @default 'alert'
     */
    readonly role: _angular_core.InputSignal<string>;
    /**
     * Set the alert variant to a solid.
     * @return string
     */
    readonly variant: _angular_core.InputSignal<"solid" | undefined>;
    /**
     * Optionally adds a close button to alert and allow it to self dismiss.
     * @return boolean
     * @default false
     */
    readonly dismissibleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
    set dismissible(value: boolean);
    get dismissible(): boolean;
    /**
     * Adds animation for dismissible alert.
     * @return boolean
     */
    readonly fade: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Toggle the visibility of alert component.
     * @return boolean
     */
    readonly visibleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
    set visible(value: boolean);
    get visible(): boolean;
    readonly hide: _angular_core.WritableSignal<boolean>;
    /**
     * Event triggered on the alert dismiss.
     */
    readonly visibleChange: _angular_core.OutputEmitterRef<boolean>;
    readonly contentTemplates: _angular_core.Signal<readonly TemplateIdDirective[]>;
    readonly templates: _angular_core.Signal<Record<string, TemplateRef<any>>>;
    get animateType(): AnimateType$1;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    onAnimationStart($event: AnimationEvent): void;
    onAnimationDone($event: AnimationEvent): void;
    onAnimationEvent(event: AnimationEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "c-alert", ["cAlert"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissibleInput": { "alias": "dismissible"; "required": false; "isSignal": true; }; "fade": { "alias": "fade"; "required": false; "isSignal": true; }; "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "visibleChange": "visibleChange"; }, ["contentTemplates"], ["*"], true, never>;
}

declare class AlertModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AlertModule, never, [typeof AlertComponent, typeof AlertHeadingDirective, typeof AlertLinkDirective], [typeof AlertComponent, typeof AlertHeadingDirective, typeof AlertLinkDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AlertModule>;
}

declare class TextColorDirective {
    /**
     * Set text-color of element
     * @type TextColors
     */
    readonly color: InputSignal<TextColors>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextColorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextColorDirective, "[cTextColor]", never, { "color": { "alias": "cTextColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AvatarComponent {
    /**
     * Sets the background color context of the component to one of CoreUI’s themed colors.
     * @type Colors
     */
    readonly color: InputSignal<Colors | undefined>;
    /**
     * Select the shape of the component.
     * @type Shapes
     */
    readonly shape: InputSignal<Shapes | undefined>;
    /**
     * Size the component small, large, or extra large.
     * @default 'md'
     */
    readonly size: InputSignal<Omit<Sizes, 'xxl'>>;
    /**
     * The alt attribute for the img element alternate text.
     * @type string
     */
    readonly alt: InputSignal<string>;
    /**
     * The src attribute for the img element.
     * @type string
     */
    readonly src: InputSignal<string | undefined>;
    /**
     * Sets the color context of the status indicator to one of CoreUI’s themed colors.
     * @type Colors
     */
    readonly status: InputSignal<Colors | undefined>;
    /**
     * Sets the text color of the component to one of CoreUI’s themed colors.
     * via TextColorDirective
     * @type TextColors
     */
    readonly textColor: InputSignal<TextColors | undefined>;
    readonly statusClass: _angular_core.Signal<Record<string, boolean>>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "c-avatar", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof TextColorDirective; inputs: { "cTextColor": "textColor"; }; outputs: {}; }]>;
}

declare class AvatarModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AvatarModule, never, [typeof AvatarComponent], [typeof AvatarComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AvatarModule>;
}

declare class TextBgColorDirective {
    /**
     * Set text-bg-color of element
     * @type Colors
     */
    readonly textBgColor: InputSignal<Colors>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextBgColorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextBgColorDirective, "[cTextBgColor]", never, { "textBgColor": { "alias": "cTextBgColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class BadgeComponent {
    /**
     * Sets the color context of the component to one of CoreUI’s themed colors.
     * @type Colors
     */
    readonly color: InputSignal<Colors | undefined>;
    /**
     * Position badge in one of the corners of a link or button.
     * @type BadgePositions
     */
    readonly position: InputSignal<BadgePositions | undefined>;
    /**
     * Select the shape of the component.
     * @type Shapes
     */
    readonly shape: InputSignal<Shapes | undefined>;
    /**
     * Size the component small.
     */
    readonly size: InputSignal<'sm' | undefined>;
    /**
     * Sets the text color of the component to one of CoreUI’s themed colors.
     * via TextColorDirective
     * @type TextColors
     */
    readonly textColor: InputSignal<TextColors | undefined>;
    /**
     * Sets the component's color scheme to one of CoreUI's themed colors, ensuring the text color contrast adheres to the WCAG 4.5:1 contrast ratio standard for accessibility.
     * via TextBgColorDirective
     * @type Colors
     * @since 5.0.0
     */
    readonly textBgColor: InputSignal<Colors | undefined>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeComponent, "c-badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; "textBgColor": { "alias": "textBgColor"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof TextColorDirective; inputs: { "cTextColor": "textColor"; }; outputs: {}; }, { directive: typeof TextBgColorDirective; inputs: { "cTextBgColor": "textBgColor"; }; outputs: {}; }]>;
}

declare class BadgeModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BadgeModule, never, [typeof BadgeComponent], [typeof BadgeComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BadgeModule>;
}

declare class BackdropService {
    #private;
    readonly backdropClick$: rxjs.Observable<boolean>;
    activeBackdrop: any;
    scrollbarWidth: string;
    setBackdrop(type?: string): any;
    clearBackdrop(backdropElement: any): any;
    hideScrollbar(): void;
    resetScrollbar(): void;
    onClickHandler(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BackdropService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BackdropService>;
}

interface IBreadcrumbItem {
    label: string;
    url?: string | any[];
    attributes?: INavAttributes$1;
    linkProps?: INavLinkProps$1;
    class?: string;
    queryParams?: {
        [key: string]: any;
    };
}

declare class BreadcrumbItemComponent {
    /**
     * Toggle the active state for the component. [docs]
     * @return boolean
     */
    readonly active: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
    /**
     * The `url` prop for the inner `[routerLink]` directive. [docs]
     * @type string
     */
    readonly url: _angular_core.InputSignal<string | any[] | undefined>;
    /**
     * Additional html attributes for link. [docs]
     * @type INavAttributes
     */
    readonly attributes: _angular_core.InputSignal<INavAttributes$1 | undefined>;
    /**
     * Some `NavigationExtras` props for the inner `[routerLink]` directive and `routerLinkActiveOptions`. [docs]
     * @type INavLinkProps
     */
    readonly linkProps: _angular_core.InputSignal<INavLinkProps$1 | undefined>;
    readonly ariaCurrent: _angular_core.Signal<string | null>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbItemComponent, "c-breadcrumb-item", ["breadcrumbItem"], { "active": { "alias": "active"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "attributes": { "alias": "attributes"; "required": false; "isSignal": true; }; "linkProps": { "alias": "linkProps"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class BreadcrumbComponent {
    /**
     * Default aria-label for breadcrumb. [docs]
     * @return string
     * @default 'breadcrumb'
     */
    readonly ariaLabel: _angular_core.InputSignal<string>;
    /**
     * Default role for breadcrumb. [docs]
     * @return string
     * @default 'navigation'
     */
    readonly role: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "c-breadcrumb", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class BreadcrumbRouterService {
    #private;
    outlet: string;
    readonly breadcrumbs$: Observable<IBreadcrumbItem[]>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbRouterService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BreadcrumbRouterService>;
}

declare class BreadcrumbRouterComponent implements OnDestroy, OnInit {
    readonly service: BreadcrumbRouterService;
    /**
     * Optional array of IBreadcrumbItem to override default BreadcrumbRouter behavior. [docs]
     * @return IBreadcrumbItem[]
     */
    readonly items: _angular_core.InputSignal<IBreadcrumbItem[] | undefined>;
    breadcrumbs: Observable<IBreadcrumbItem[]> | undefined;
    ngOnInit(): void;
    readonly setup: _angular_core.EffectRef;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbRouterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbRouterComponent, "c-breadcrumb-router, [cBreadcrumbRouter]", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class BreadcrumbModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BreadcrumbModule, never, [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent, typeof BreadcrumbRouterComponent], [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent, typeof BreadcrumbRouterComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BreadcrumbModule>;
}

declare class ButtonDirective {
    static ngAcceptInputType_active: BooleanInput;
    static ngAcceptInputType_disabled: BooleanInput;
    /**
     * Toggle the active state for the component. [docs]
     * @type InputSignalWithTransform<boolean, unknown>
     */
    readonly active: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
     * @type InputSignal<Colors>
     */
    readonly color: InputSignal<Colors>;
    /**
     * Toggle the disabled state for the component.
     * @type InputSignalWithTransform<boolean, unknown>
     */
    readonly disabled: InputSignalWithTransform<boolean, unknown>;
    /**
     * Select the shape of the component.
     * @type InputSignal<Shapes>
     */
    readonly shape: InputSignal<Shapes | undefined>;
    /**
     * Size the component small or large.
     * @type InputSignal<'sm' | 'lg' | ''>
     */
    readonly size: InputSignal<'' | 'sm' | 'lg'>;
    /**
     * The tabindex attribute specifies the tab order of an element (when the "tab" button is used for navigating).
     */
    readonly tabindex: InputSignalWithTransform<number | undefined, unknown>;
    /**
     * Specifies the type of button. Always specify the type attribute for the `<button>` element.
     * Different browsers may use different default types for the `<button>` element.
     * @type InputSignal<ButtonType>
     * @default 'button'
     */
    readonly type: InputSignal<ButtonType>;
    /**
     * Set the button variant to an outlined button or a ghost button.
     * @type InputSignal<'ghost' | 'outline' | undefined>
     */
    readonly variant: InputSignal<'ghost' | 'outline' | undefined>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    readonly _disabled: _angular_core.Signal<boolean>;
    readonly ariaDisabled: _angular_core.Signal<true | null>;
    readonly attrDisabled: _angular_core.Signal<"" | null>;
    readonly tabIndex: _angular_core.Signal<number | "-1" | null>;
    readonly isActive: _angular_core.Signal<true | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[cButton]", ["cButton"], { "active": { "alias": "active"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ButtonCloseDirective extends ButtonDirective {
    /**
     * Change the default color to white.
     * @type boolean
     * @deprecated 5.0.0. Use `cButtonClose.dark` instead.
     */
    readonly white: InputSignalWithTransform<boolean, unknown>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonCloseDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonCloseDirective, "[cButtonClose]", never, { "white": { "alias": "white"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ThemeDirective; inputs: { "dark": "dark"; }; outputs: {}; }]>;
}

declare class ButtonModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof ButtonDirective, typeof ButtonCloseDirective], [typeof ButtonDirective, typeof ButtonCloseDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ButtonModule>;
}

declare class ButtonGroupComponent {
    /**
     * Size the component small or large.
     * @type { 'sm' | 'lg' }
     */
    readonly size: InputSignal<'sm' | 'lg' | undefined>;
    /**
     * Create a set of buttons that appear vertically stacked rather than horizontally. Split button dropdowns are not supported here.
     * @type boolean
     */
    readonly vertical: InputSignalWithTransform<boolean, unknown>;
    /**
     * Default role attr for ButtonGroup. [docs]
     * @type InputSignal<string>
     * @default 'group'
     */
    readonly role: InputSignal<string>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "c-button-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ButtonToolbarComponent {
    /**
     * Default role attr for ButtonToolbar. [docs]
     * @type InputSignal<string>
     * @default 'toolbar'
     */
    role: InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonToolbarComponent, "c-button-toolbar", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ButtonGroupModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ButtonGroupModule, never, [typeof ButtonGroupComponent, typeof ButtonToolbarComponent], [typeof ButtonGroupComponent, typeof ButtonToolbarComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ButtonGroupModule>;
}

type DateFilterType = (date: Date) => boolean;
type DayFormatType = 'numeric' | '2-digit' | ((date: Date) => string | number);
type WeekdayFormatType = number | 'long' | 'narrow' | 'short' | ((date: Date) => string | number);
type SelectionType = 'day' | 'week' | 'month' | 'year';
type DaysOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
type MonthDetails = {
    weekNumber: number;
    days: {
        date: Date;
        month: string;
    }[];
}[];

interface INavigationClick {
    direction: 'prev' | 'next';
    years: boolean;
}
declare class CalendarNavigationComponent {
    #private;
    constructor();
    readonly pageIndex: _angular_core.InputSignalWithTransform<number, unknown>;
    readonly addMonths: _angular_core.Signal<number>;
    readonly navigation: _angular_core.InputSignal<boolean>;
    readonly maxDate: _angular_core.WritableSignal<Date | null>;
    readonly minDate: _angular_core.WritableSignal<Date | null>;
    readonly calendarDate: _angular_core.WritableSignal<Date>;
    readonly navYearFirst: _angular_core.WritableSignal<boolean>;
    readonly locale: _angular_core.WritableSignal<string>;
    readonly view: _angular_core.WritableSignal<"days" | "months" | "years">;
    readonly selectionType: _angular_core.WritableSignal<SelectionType>;
    readonly ariaNextMonthLabel: _angular_core.InputSignal<string>;
    readonly ariaNextYearLabel: _angular_core.InputSignal<string>;
    readonly ariaPrevMonthLabel: _angular_core.InputSignal<string>;
    readonly ariaPrevYearLabel: _angular_core.InputSignal<string>;
    readonly navigationClick: _angular_core.OutputEmitterRef<INavigationClick>;
    readonly date: _angular_core.Signal<Date>;
    readonly disableNextMonth: _angular_core.Signal<boolean>;
    readonly disablePrevMonth: _angular_core.Signal<boolean>;
    readonly disableNextYear: _angular_core.Signal<boolean>;
    readonly disablePrevYear: _angular_core.Signal<boolean>;
    calendarStateSubscribe(): void;
    setView(view: 'days' | 'months' | 'years'): void;
    handleNavigationClick(direction: 'prev' | 'next', years?: boolean): void;
    handleNavigationKeyUp($event: KeyboardEvent, direction: 'prev' | 'next', years?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarNavigationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarNavigationComponent, "c-calendar-navigation", never, { "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; "ariaNextMonthLabel": { "alias": "ariaNextMonthLabel"; "required": false; "isSignal": true; }; "ariaNextYearLabel": { "alias": "ariaNextYearLabel"; "required": false; "isSignal": true; }; "ariaPrevMonthLabel": { "alias": "ariaPrevMonthLabel"; "required": false; "isSignal": true; }; "ariaPrevYearLabel": { "alias": "ariaPrevYearLabel"; "required": false; "isSignal": true; }; }, { "navigationClick": "navigationClick"; }, never, never, true, never>;
}

declare class CalendarDayDirective implements FocusableOption {
    #private;
    readonly elementRef: ElementRef<any>;
    readonly focusMonitor: FocusMonitor;
    constructor();
    readonly date: _angular_core.InputSignal<Date | undefined>;
    readonly month: _angular_core.InputSignal<string>;
    disabled: boolean;
    readonly disabled$: _angular_core.Signal<boolean>;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean> | undefined>;
    readonly ariaSelected: _angular_core.Signal<true | null>;
    focus(origin?: FocusOrigin): void;
    getLabel(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarDayDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarDayDirective, "[cCalendarDay]", ["cCalendarDay"], { "date": { "alias": "date"; "required": false; "isSignal": true; }; "month": { "alias": "month"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CalendarRowDirective implements FocusableOption {
    #private;
    elementRef: ElementRef<any>;
    focusMonitor: FocusMonitor;
    constructor();
    set week(value: {
        weekNumber: number;
        days: {
            date: Date;
            month: string;
        }[];
    });
    get week(): {
        weekNumber: number;
        days: {
            date: Date;
            month: string;
        }[];
    };
    date: Date | null;
    private startDate;
    private endDate;
    private hoverDate;
    private maxDate;
    private minDate;
    private range;
    private selectionType;
    private disabledDates;
    private dateFilter;
    private calendarDate;
    private locale;
    disabled: boolean;
    current: boolean;
    readonly tabindex: _angular_core.WritableSignal<number>;
    get selectEndDate(): boolean;
    get hostClasses(): any;
    get ariaSelected(): true | null;
    focus(origin?: FocusOrigin): void;
    getLabel(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarRowDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarRowDirective, "[cCalendarRow]", ["cCalendarRow"], { "week": { "alias": "cCalendarRow"; "required": true; }; }, {}, never, never, true, never>;
}

declare class CalendarMonthComponent {
    #private;
    constructor();
    readonly pageIndex: _angular_core.InputSignalWithTransform<number, unknown>;
    readonly addMonths: _angular_core.Signal<number>;
    /**
     * Initial selected date.
     * @type  (Date | null)
     */
    readonly startDate: _angular_core.WritableSignal<Date | null>;
    /**
     * Initial selected to date (range).
     * @type  Date | null
     */
    readonly endDate: _angular_core.WritableSignal<Date | null>;
    readonly datesEffect: _angular_core.EffectRef;
    /**
     * Specify the list of dates that cannot be selected.
     * @type  Date[] | Date[][]
     */
    readonly disabledDates: _angular_core.WritableSignal<(Date | Date[])[]>;
    /**
     * Sets the day of start week.
     * - 0 - Sunday,
     * - 1 - Monday,
     * - 2 - Tuesday,
     * - 3 - Wednesday,
     * - 4 - Thursday,
     * - 5 - Friday,
     * - 6 - Saturday,
     */
    readonly firstDayOfWeek: _angular_core.WritableSignal<number>;
    /**
     * Sets the default locale for components. If not set, it is inherited from the browser.
     * @default 'default'
     */
    readonly locale: _angular_core.WritableSignal<string>;
    /**
     * Allow range selection.
     * @type boolean
     * @default false
     */
    readonly range: _angular_core.WritableSignal<boolean>;
    /**
     * Set length or format of day name.
     * @type number | 'long' | 'narrow' | 'short'
     * @default 'short'
     */
    readonly weekdayFormat: _angular_core.WritableSignal<number | "long" | "short" | "narrow">;
    /**
     * Set calendar view.
     * @type 'days' | 'months' | 'years'
     * @default 'days'
     */
    readonly view: _angular_core.WritableSignal<"days" | "months" | "years">;
    /**
     * Max selectable date.
     */
    readonly maxDate: _angular_core.WritableSignal<Date | null>;
    /**
     * Min selectable date.
     */
    readonly minDate: _angular_core.WritableSignal<Date | null>;
    readonly listOfMonths: _angular_core.Signal<{
        year: number;
        month: string;
    }[][]>;
    readonly listOfYears: _angular_core.Signal<number[][]>;
    /**
     * Default date of the component
     * @type Date
     */
    readonly calendarDate: _angular_core.WritableSignal<Date>;
    readonly date: _angular_core.Signal<Date>;
    readonly calendarDateEffect: _angular_core.EffectRef;
    calendarDays: QueryList<CalendarDayDirective>;
    calendarRows: QueryList<CalendarRowDirective>;
    readonly dateFilter: _angular_core.WritableSignal<DateFilterType | undefined>;
    readonly dayFormat: _angular_core.WritableSignal<DayFormatType>;
    readonly selectAdjacentDays: _angular_core.WritableSignal<boolean>;
    readonly showAdjacentDays: _angular_core.WritableSignal<boolean>;
    readonly selectionType: _angular_core.WritableSignal<SelectionType>;
    readonly showWeekNumber: _angular_core.WritableSignal<boolean>;
    readonly weekNumbersLabel: _angular_core.WritableSignal<string>;
    readonly monthDetails: _angular_core.Signal<MonthDetails>;
    readonly weekDays: _angular_core.Signal<{
        date: Date;
        month: string;
    }[]>;
    yearNumber(year: any): string;
    isDateDisabled(date: Date): boolean;
    calendarCellTitle(date: Date): string;
    handleCellMouseEnter(hoverDate: Date | undefined): void;
    handleYearCellClick(year: number): void;
    handleYearCellKeyUp($event: KeyboardEvent, date: Date | undefined): void;
    handleMonthCellKeyUp($event: KeyboardEvent, date: Date | undefined): void;
    handleMonthCellClick(value: Date | undefined): void;
    setCalendarPage(years: number, months?: number, setMonth?: number): void;
    handleDayCellKeyDown($event: KeyboardEvent, date: Date | undefined): void;
    handleCellMouseLeave(): void;
    handleDayCellKeyUp($event: KeyboardEvent, date: Date): void;
    handleDayCellClick(date: Date): void;
    calendarStateSubscribe(): void;
    getMonthStart(index: number): Date;
    getMonthEnd(index: number): Date;
    getYearStart(year: number): Date;
    getYearEnd(year: number): Date;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarMonthComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarMonthComponent, "c-calendar-month", ["cCalendarMonth"], { "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CalendarComponent implements OnInit, AfterViewInit {
    #private;
    readonly calendarDateChange: _angular_core.OutputEmitterRef<Date>;
    /**
     * Default date of the component
     * @type  Date | string
     */
    readonly calendarDateModel: _angular_core.ModelSignal<string | number | Date>;
    readonly calendarDate: _angular_core.Signal<Date>;
    readonly calendarDateEffect: _angular_core.EffectRef;
    /**
     * The number of calendars that render on desktop devices.
     * @type number
     * default 1
     */
    readonly calendars: _angular_core.InputSignalWithTransform<number, unknown>;
    readonly calendarsArray: _angular_core.Signal<number[]>;
    /**
     * Set the format of day name.
     * @default 'numeric'
     * @type DayFormatType
     */
    readonly dayFormat: _angular_core.InputSignal<DayFormatType>;
    readonly dayFormatEffect: _angular_core.EffectRef;
    /**
     * Specify the list of dates that cannot be selected.
     * @type (Date | Date[])[]
     */
    readonly disabledDates: _angular_core.InputSignal<(Date | Date[])[]>;
    readonly disabledDatesEffect: _angular_core.EffectRef;
    readonly endDateChange: _angular_core.OutputEmitterRef<Date | null>;
    readonly startDateChange: _angular_core.OutputEmitterRef<Date | null>;
    /**
     * Initial selected date.
     * @type  (Date | null)
     */
    readonly startDateModel: _angular_core.ModelSignal<string | number | Date | null>;
    readonly startDate: _angular_core.Signal<Date | null>;
    /**
     * Initial selected to date (range).
     * @type Date | null
     */
    readonly endDateModel: _angular_core.ModelSignal<string | number | Date | null>;
    readonly endDate: _angular_core.Signal<Date | null>;
    /**
     * Sets the day of start week.
     * - 0 - Sunday,
     * - 1 - Monday,
     * - 2 - Tuesday,
     * - 3 - Wednesday,
     * - 4 - Thursday,
     * - 5 - Friday,
     * - 6 - Saturday,
     *
     * @type number
     * @default 1
     */
    readonly firstDayOfWeek: _angular_core.InputSignal<DaysOfWeek>;
    readonly firstDayOfWeekEffect: _angular_core.EffectRef;
    /**
     * Sets the default locale for components. If not set, it is inherited from the browser.
     * @default 'default'
     */
    readonly locale: _angular_core.InputSignal<string>;
    readonly localeEffect: _angular_core.EffectRef;
    /**
     * Max selectable date.
     */
    readonly maxDateInput: _angular_core.InputSignal<string | number | Date | null>;
    readonly maxDateEffect: _angular_core.EffectRef;
    /**
     * Min selectable date.
     */
    readonly minDateInput: _angular_core.InputSignal<string | number | Date | null>;
    readonly minDateEffect: _angular_core.EffectRef;
    /**
     * Show navigation.
     * @type boolean
     */
    readonly navigation: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Reorder year-month navigation, and render year first.
     * @type boolean
     * @default false
     */
    readonly navYearFirst: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly navYearFirstEffect: _angular_core.EffectRef;
    /**
     * Allow range selection.
     * @type boolean
     * @default false
     */
    readonly range: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly rangeEffect: _angular_core.EffectRef;
    /**
     * Set calendar view.
     * @type 'days' | 'months' | 'years'
     * @default 'days'
     */
    readonly view: _angular_core.ModelSignal<"days" | "months" | "years">;
    readonly viewEffect: _angular_core.EffectRef;
    /**
     * Set length or format of day name.
     * @type number | 'long' | 'narrow' | 'short'
     * @default 'short'
     */
    readonly weekdayFormat: _angular_core.InputSignal<WeekdayFormatType>;
    readonly weekdayFormatEffect: _angular_core.EffectRef;
    readonly dateFilter: _angular_core.InputSignal<DateFilterType | undefined>;
    readonly dateFilterEffect: _angular_core.EffectRef;
    /**
     * Set whether days in adjacent months shown before or after the current month are selectable. This only applies if the `showAdjacentDays` option is set to true.
     * @type boolean
     * @default false
     * @since 4.4.10
     */
    readonly selectAdjacentDays: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly selectAdjacentDaysEffect: _angular_core.EffectRef;
    /**
     * Set whether to display dates in adjacent months (non-selectable) at the start and end of the current month.
     * @type boolean
     * @default true
     * @since 4.4.10
     */
    readonly showAdjacentDays: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly showAdjacentDaysEffect: _angular_core.EffectRef;
    /**
     * Specify the type of date selection as day, week, month, or year.
     * @type 'day' | 'week' | 'month' | 'year'
     * @default 'day'
     * @since 5.0.0
     */
    readonly selectionType: _angular_core.InputSignal<SelectionType>;
    readonly selectionTypeEffect: _angular_core.EffectRef;
    /**
     * Set whether to display week numbers in the calendar.
     * @type boolean
     * @default false
     * @since 5.0.0
     */
    readonly showWeekNumber: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly showWeekNumberEffect: _angular_core.EffectRef;
    /**
     * Label displayed over week numbers in the calendar.
     * @type string
     * @default undefined
     * @since 5.0.0
     */
    readonly weekNumbersLabel: _angular_core.InputSignal<string | undefined>;
    readonly weekNumbersLabelEffect: _angular_core.EffectRef;
    readonly ariaNextMonthLabel: _angular_core.InputSignal<string>;
    readonly ariaNextYearLabel: _angular_core.InputSignal<string>;
    readonly ariaPrevMonthLabel: _angular_core.InputSignal<string>;
    readonly ariaPrevYearLabel: _angular_core.InputSignal<string>;
    readonly calendarCellHover: _angular_core.OutputEmitterRef<Date | null>;
    readonly hoverDate: _angular_core.WritableSignal<Date | null>;
    readonly hoverDateEffect: _angular_core.EffectRef;
    readonly hostClasses: _angular_core.Signal<Record<string, boolean>>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    calendarStateSubscribe(): void;
    setCalendarPage(years: number, months?: number, setMonth?: number): void;
    handleNavigationClick(direction: 'prev' | 'next', years?: boolean): void;
    /**
     * Clear startDate and endDate
     * @type void
     */
    clearDates(): void;
    handleFocusChange($event: FocusOrigin): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "c-calendar", ["cCalendar"], { "calendarDateModel": { "alias": "calendarDate"; "required": false; "isSignal": true; }; "calendars": { "alias": "calendars"; "required": false; "isSignal": true; }; "dayFormat": { "alias": "dayFormat"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "startDateModel": { "alias": "startDate"; "required": false; "isSignal": true; }; "endDateModel": { "alias": "endDate"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "maxDateInput": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minDateInput": { "alias": "minDate"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; "navYearFirst": { "alias": "navYearFirst"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "weekdayFormat": { "alias": "weekdayFormat"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "selectAdjacentDays": { "alias": "selectAdjacentDays"; "required": false; "isSignal": true; }; "showAdjacentDays": { "alias": "showAdjacentDays"; "required": false; "isSignal": true; }; "selectionType": { "alias": "selectionType"; "required": false; "isSignal": true; }; "showWeekNumber": { "alias": "showWeekNumber"; "required": false; "isSignal": true; }; "weekNumbersLabel": { "alias": "weekNumbersLabel"; "required": false; "isSignal": true; }; "ariaNextMonthLabel": { "alias": "ariaNextMonthLabel"; "required": false; "isSignal": true; }; "ariaNextYearLabel": { "alias": "ariaNextYearLabel"; "required": false; "isSignal": true; }; "ariaPrevMonthLabel": { "alias": "ariaPrevMonthLabel"; "required": false; "isSignal": true; }; "ariaPrevYearLabel": { "alias": "ariaPrevYearLabel"; "required": false; "isSignal": true; }; }, { "calendarDateChange": "calendarDateChange"; "calendarDateModel": "calendarDateChange"; "endDateChange": "endDateChange"; "startDateChange": "startDateChange"; "startDateModel": "startDateChange"; "endDateModel": "endDateChange"; "view": "viewChange"; "calendarCellHover": "calendarCellHover"; }, never, never, true, never>;
}

declare class CalendarClassYearPipe implements PipeTransform {
    transform(year: number, args?: any): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarClassYearPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CalendarClassYearPipe, "calendarClassYear", true>;
}

declare class CalendarClassDayPipe implements PipeTransform {
    transform(dateObj: {
        date: Date;
        month: string;
    }, datesConfig?: {
        minDate: any;
        maxDate: any;
        disabledDates: any;
        dateFilter: any;
    }): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarClassDayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CalendarClassDayPipe, "calendarClassDay", true>;
}

declare class CalendarClassMonthPipe implements PipeTransform {
    transform(calendarDate: string | number | Date, monthIndex: number): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarClassMonthPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CalendarClassMonthPipe, "calendarClassMonth", true>;
}

declare class CalendarClassViewPipe implements PipeTransform {
    transform(view: string): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarClassViewPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CalendarClassViewPipe, "calendarClassView", true>;
}

declare class CalendarDayPipe implements PipeTransform {
    transform(date: Date, dayFormat?: DayFormatType, locale?: string): (string | number);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarDayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CalendarDayPipe, "calendarDay", true>;
}

declare class CalendarWeekdayPipe implements PipeTransform {