@coreui/angular
Version:
CoreUI Components Library for Angular
1,031 lines (968 loc) • 186 kB
TypeScript
import { IsActiveMatchOptions, UrlTree, Router, NavigationEnd } from '@angular/router';
import * as i0 from '@angular/core';
import { ElementRef, TemplateRef, ModuleWithProviders, OnInit, OnDestroy, InputSignal, InputSignalWithTransform, AfterContentInit, AfterContentChecked, AfterViewInit, Renderer2, ViewContainerRef, WritableSignal, OnChanges, SimpleChanges, PipeTransform, QueryList, ModelSignal, OutputEmitterRef, ComponentRef, Injector, NgModuleRef, ChangeDetectorRef } from '@angular/core';
import { AnimationEvent } from '@angular/animations';
import * as rxjs from 'rxjs';
import { Observable, Subscription } from 'rxjs';
import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
import * as _popperjs_core from '@popperjs/core';
import { Placement, Options } from '@popperjs/core';
import { BooleanInput as BooleanInput$1, NumberInput as NumberInput$1 } from '@angular/cdk/coercion';
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: i0.ɵɵFactoryDeclaration<ElementRefDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<ElementRefDirective, "[cElementRef]", ["cElementRef"], {}, {}, never, never, true, never>;
}
declare class HtmlAttributesDirective {
#private;
readonly cHtmlAttr: i0.InputSignal<Record<string, any> | undefined>;
private setStyle;
private addClass;
private setAttrib;
static ɵfac: i0.ɵɵFactoryDeclaration<HtmlAttributesDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<HtmlAttributesDirective, "[cHtmlAttr]", ["cHtmlAttr"], { "cHtmlAttr": { "alias": "cHtmlAttr"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TemplateIdDirective {
readonly templateRef: TemplateRef<any>;
readonly cTemplateId: i0.InputSignal<string>;
get id(): string;
static ɵfac: i0.ɵɵFactoryDeclaration<TemplateIdDirective, never>;
static ɵdir: i0.ɵɵ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: i0.InputSignal<"dark" | "light" | undefined>;
readonly dark: i0.InputSignalWithTransform<boolean, unknown>;
setTheme(theme?: string): void;
unsetTheme(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<ThemeDirective, never>;
static ɵdir: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<SharedModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, never, [typeof ElementRefDirective, typeof HtmlAttributesDirective, typeof TemplateIdDirective, typeof ThemeDirective], [typeof ElementRefDirective, typeof HtmlAttributesDirective, typeof TemplateIdDirective, typeof ThemeDirective]>;
static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
}
declare class AccordionButtonDirective {
/**
* Toggles an accordion button collapsed state. Use in accordionHeaderTemplate. [docs]
* @type boolean
*/
readonly collapsed: i0.InputSignal<boolean | undefined>;
/**
* Default type for cAccordionButton. [docs]
* @type string
* @default 'button'
*/
readonly type: i0.InputSignal<string>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
readonly ariaExpanded: i0.Signal<boolean>;
static ɵfac: i0.ɵɵFactoryDeclaration<AccordionButtonDirective, never>;
static ɵdir: i0.ɵɵ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: i0.InputSignalWithTransform<boolean, unknown>;
/**
* Make accordion items stay open when another item is opened
* @type boolean
*/
readonly alwaysOpen: i0.InputSignalWithTransform<boolean, unknown>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.InputSignalWithTransform<boolean, unknown>;
readonly itemVisible: i0.WritableSignal<boolean>;
set visible(value: boolean);
get visible(): boolean;
contentId: string;
get itemContext(): {
$implicit: boolean;
};
readonly contentTemplates: i0.Signal<readonly TemplateIdDirective[]>;
readonly templates: i0.Signal<Record<string, TemplateRef<any>>>;
ngOnInit(): void;
ngOnDestroy(): void;
toggleItem(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "c-accordion-item", ["cAccordionItem"], { "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, ["contentTemplates"], ["*", "*"], true, never>;
}
declare class AccordionModule {
static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof AccordionButtonDirective, typeof AccordionComponent, typeof AccordionItemComponent], [typeof AccordionComponent, typeof AccordionButtonDirective, typeof AccordionItemComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
}
declare class AlertHeadingDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<AlertHeadingDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<AlertHeadingDirective, "[cAlertHeading]", never, {}, {}, never, never, true, never>;
}
declare class AlertLinkDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<AlertLinkDirective, never>;
static ɵdir: i0.ɵɵ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: i0.InputSignal<string>;
/**
* Default role for alert. [docs]
* @return string
* @default 'alert'
*/
readonly role: i0.InputSignal<string>;
/**
* Set the alert variant to a solid.
* @return string
*/
readonly variant: i0.InputSignal<"solid" | undefined>;
/**
* Optionally adds a close button to alert and allow it to self dismiss.
* @return boolean
* @default false
*/
readonly dismissibleInput: i0.InputSignalWithTransform<boolean, unknown>;
set dismissible(value: boolean);
get dismissible(): boolean;
/**
* Adds animation for dismissible alert.
* @return boolean
*/
readonly fade: i0.InputSignalWithTransform<boolean, unknown>;
/**
* Toggle the visibility of alert component.
* @return boolean
*/
readonly visibleInput: i0.InputSignalWithTransform<boolean, unknown>;
set visible(value: boolean);
get visible(): boolean;
readonly hide: i0.WritableSignal<boolean>;
/**
* Event triggered on the alert dismiss.
*/
readonly visibleChange: i0.OutputEmitterRef<boolean>;
readonly contentTemplates: i0.Signal<readonly TemplateIdDirective[]>;
readonly templates: i0.Signal<Record<string, TemplateRef<any>>>;
get animateType(): AnimateType$1;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
onAnimationStart($event: AnimationEvent): void;
onAnimationDone($event: AnimationEvent): void;
onAnimationEvent(event: AnimationEvent): void;
static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<AlertModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<AlertModule, never, [typeof AlertComponent, typeof AlertHeadingDirective, typeof AlertLinkDirective], [typeof AlertComponent, typeof AlertHeadingDirective, typeof AlertLinkDirective]>;
static ɵinj: i0.ɵɵInjectorDeclaration<AlertModule>;
}
declare class TextColorDirective {
/**
* Set text-color of element
* @type TextColors
*/
readonly color: InputSignal<TextColors>;
readonly hostClasses: i0.Signal<{
[x: string]: boolean;
}>;
static ɵfac: i0.ɵɵFactoryDeclaration<TextColorDirective, never>;
static ɵdir: i0.ɵɵ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: i0.Signal<Record<string, boolean>>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<AvatarModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarModule, never, [typeof AvatarComponent], [typeof AvatarComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<AvatarModule>;
}
declare class TextBgColorDirective {
/**
* Set text-bg-color of element
* @type Colors
*/
readonly textBgColor: InputSignal<Colors>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<TextBgColorDirective, never>;
static ɵdir: i0.ɵɵ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: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<BadgeModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<BadgeModule, never, [typeof BadgeComponent], [typeof BadgeComponent]>;
static ɵinj: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<BackdropService, never>;
static ɵprov: i0.ɵɵ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: i0.InputSignalWithTransform<boolean | undefined, unknown>;
/**
* The `url` prop for the inner `[routerLink]` directive. [docs]
* @type string
*/
readonly url: i0.InputSignal<string | any[] | undefined>;
/**
* Additional html attributes for link. [docs]
* @type INavAttributes
*/
readonly attributes: i0.InputSignal<INavAttributes$1 | undefined>;
/**
* Some `NavigationExtras` props for the inner `[routerLink]` directive and `routerLinkActiveOptions`. [docs]
* @type INavLinkProps
*/
readonly linkProps: i0.InputSignal<INavLinkProps$1 | undefined>;
readonly ariaCurrent: i0.Signal<string | null>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.InputSignal<string>;
/**
* Default role for breadcrumb. [docs]
* @return string
* @default 'navigation'
*/
readonly role: i0.InputSignal<string>;
static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<BreadcrumbRouterService, never>;
static ɵprov: i0.ɵɵ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: i0.InputSignal<IBreadcrumbItem[] | undefined>;
breadcrumbs: Observable<IBreadcrumbItem[]> | undefined;
ngOnInit(): void;
readonly setup: i0.EffectRef;
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbRouterComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbRouterComponent, "c-breadcrumb-router, [cBreadcrumbRouter]", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class BreadcrumbModule {
static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, never, [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent, typeof BreadcrumbRouterComponent], [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent, typeof BreadcrumbRouterComponent]>;
static ɵinj: i0.ɵɵ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: i0.Signal<Record<string, boolean>>;
readonly _disabled: i0.Signal<boolean>;
readonly ariaDisabled: i0.Signal<true | null>;
readonly attrDisabled: i0.Signal<"" | null>;
readonly tabIndex: i0.Signal<number | "-1" | null>;
readonly isActive: i0.Signal<true | null>;
static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
static ɵdir: i0.ɵɵ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: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<ButtonCloseDirective, never>;
static ɵdir: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof ButtonDirective, typeof ButtonCloseDirective], [typeof ButtonDirective, typeof ButtonCloseDirective]>;
static ɵinj: i0.ɵɵ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: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
static ɵcmp: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<ButtonToolbarComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<ButtonToolbarComponent, "c-button-toolbar", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class ButtonGroupModule {
static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonGroupModule, never, [typeof ButtonGroupComponent, typeof ButtonToolbarComponent], [typeof ButtonGroupComponent, typeof ButtonToolbarComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<ButtonGroupModule>;
}
declare class CalloutComponent {
/**
* Sets the color context of the component to one of CoreUI’s themed colors.
* @type Colors
*/
readonly color: i0.InputSignal<string | undefined>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<CalloutComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CalloutComponent, "c-callout, [cCallout]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class CalloutModule {
static ɵfac: i0.ɵɵFactoryDeclaration<CalloutModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<CalloutModule, never, [typeof CalloutComponent], [typeof CalloutComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<CalloutModule>;
}
declare class CardComponent {
/**
* Sets the color context of the component to one of CoreUI’s themed colors.
* @type Colors
*/
readonly color: InputSignal<Colors | undefined>;
/**
* Sets the text color context 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 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: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "c-card, [c-card]", never, { "color": { "alias": "color"; "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 CardBodyComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardBodyComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardBodyComponent, "c-card-body, [c-card-body]", never, {}, {}, never, ["*"], true, never>;
}
declare class CardFooterComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardFooterComponent, "c-card-footer, [c-card-footer]", never, {}, {}, never, ["*"], true, never>;
}
declare class CardGroupComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardGroupComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardGroupComponent, "c-card-group, [c-card-group]", never, {}, {}, never, ["*"], true, never>;
}
declare class CardHeaderComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "c-card-header, [c-card-header]", never, {}, {}, never, ["*"], true, never>;
}
declare class CardHeaderActionsComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderActionsComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderActionsComponent, "c-card-header-actions, [c-card-header-actions]", never, {}, {}, never, ["*"], true, never>;
}
declare class CardImgDirective {
/**
* Optionally orientate the image to the top, bottom, or make it overlaid across the card.
* @type {'top | 'bottom'}
*/
readonly orientation: i0.InputSignal<"start" | "end" | "top" | "bottom" | undefined>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
static ɵfac: i0.ɵɵFactoryDeclaration<CardImgDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CardImgDirective, "[cCardImg]", never, { "orientation": { "alias": "cCardImg"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class CardImgOverlayComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CardImgOverlayComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CardImgOverlayComponent, "c-card-img-overlay", never, {}, {}, never, ["*"], true, never>;
}
declare class CardLinkDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<CardLinkDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CardLinkDirective, "[cCardLink]", never, {}, {}, never, never, true, never>;
}
declare class CardSubtitleDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<CardSubtitleDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CardSubtitleDirective, "[cCardSubtitle]", never, {}, {}, never, never, true, never>;
}
declare class CardTextDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<CardTextDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CardTextDirective, "[cCardText]", never, {}, {}, never, never, true, never>;
}
declare class CardTitleDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<CardTitleDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CardTitleDirective, "[cCardTitle]", never, {}, {}, never, never, true, never>;
}
declare class CardModule {
static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof CardComponent, typeof CardBodyComponent, typeof CardFooterComponent, typeof CardGroupComponent, typeof CardHeaderComponent, typeof CardHeaderActionsComponent, typeof CardImgDirective, typeof CardImgOverlayComponent, typeof CardLinkDirective, typeof CardSubtitleDirective, typeof CardTextDirective, typeof CardTitleDirective], [typeof CardComponent, typeof CardBodyComponent, typeof CardFooterComponent, typeof CardGroupComponent, typeof CardHeaderComponent, typeof CardHeaderActionsComponent, typeof CardImgDirective, typeof CardImgOverlayComponent, typeof CardLinkDirective, typeof CardSubtitleDirective, typeof CardTextDirective, typeof CardTitleDirective]>;
static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
}
declare class CarouselComponent implements OnInit, OnDestroy, AfterContentInit {
#private;
private config;
constructor();
loadConfig(): void;
/**
* Index of the active item.
* @return number
*/
readonly activeIndexInput: i0.InputSignalWithTransform<number, unknown>;
readonly activeIndex: i0.WritableSignal<number>;
/**
* Carousel automatically starts cycle items.
* @return boolean
*/
readonly animateInput: i0.InputSignal<boolean>;
readonly animate: i0.WritableSignal<boolean>;
/**
* Carousel direction. [docs]
* @return {'next' | 'prev'}
*/
readonly directionInput: i0.InputSignal<"next" | "prev">;
readonly direction: i0.WritableSignal<"next" | "prev">;
/**
* The amount of time to delay between automatically cycling an item. If false, carousel will not automatically cycle.
* @return number
* @default 0
*/
readonly intervalInput: i0.InputSignalWithTransform<number, unknown>;
readonly interval: i0.WritableSignal<number>;
/**
* Sets which event handlers you’d like provided to your pause prop. You can specify one trigger or an array of them.
* @return {'hover' | 'focus' | 'click'}
*/
readonly pause: i0.InputSignal<false | Triggers | Triggers[]>;
/**
* Support left/right swipe interactions on touchscreen devices.
* @return boolean
* @default true
*/
readonly touch: i0.InputSignal<boolean>;
/**
* Set type of the transition.
* @return {'slide' | 'crossfade'}
* @default 'slide'
*/
readonly transition: i0.InputSignal<"slide" | "crossfade">;
/**
* Set whether the carousel should cycle continuously or have hard stops.
* @return boolean
* @default true
*/
readonly wrap: i0.InputSignal<boolean>;
/**
* Event emitted on carousel item change. [docs]
* @return number
*/
readonly itemChange: i0.OutputEmitterRef<number>;
private timerId;
private activeItemInterval;
private swipeSubscription?;
ngOnInit(): void;
ngOnDestroy(): void;
ngAfterContentInit(): void;
private setListeners;
private clearListeners;
set visible(value: boolean);
get visible(): boolean;
setTimer(): void;
resetTimer(): void;
private carouselStateSubscribe;
private intersectionServiceSubscribe;
private swipeSubscribe;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselComponent, "c-carousel", ["cCarousel"], { "activeIndexInput": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "animateInput": { "alias": "animate"; "required": false; "isSignal": true; }; "directionInput": { "alias": "direction"; "required": false; "isSignal": true; }; "intervalInput": { "alias": "interval"; "required": false; "isSignal": true; }; "pause": { "alias": "pause"; "required": false; "isSignal": true; }; "touch": { "alias": "touch"; "required": false; "isSignal": true; }; "transition": { "alias": "transition"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, { "itemChange": "itemChange"; }, never, ["*"], true, [{ directive: typeof ThemeDirective; inputs: { "dark": "dark"; }; outputs: {}; }]>;
}
declare class CarouselCaptionComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselCaptionComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselCaptionComponent, "c-carousel-caption", never, {}, {}, never, ["*"], true, never>;
}
declare class CarouselControlComponent {
#private;
/**
* Carousel control caption. [docs]
* @return string
*/
readonly captionInput: i0.InputSignal<string | undefined>;
readonly caption: i0.WritableSignal<string>;
/**
* Carousel control direction.
* @return {'next' | 'prev'}
*/
readonly direction: i0.InputSignal<"next" | "prev">;
/**
* Carousel control role.
* @return string
*/
readonly role: i0.InputSignal<string>;
readonly hostClasses: i0.Signal<string>;
readonly carouselControlIconClass: i0.Signal<string>;
onKeyUp($event: KeyboardEvent): void;
onClick($event: MouseEvent): void;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselControlComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselControlComponent, "c-carousel-control", ["cCarouselControl"], { "captionInput": { "alias": "caption"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class CarouselIndicatorsComponent implements OnInit {
#private;
items: (number | undefined)[];
active: number;
readonly contentTemplates: i0.Signal<readonly TemplateIdDirective[]>;
readonly templates: i0.Signal<Record<string, TemplateRef<any>>>;
ngOnInit(): void;
onClick(index: number): void;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselIndicatorsComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselIndicatorsComponent, "c-carousel-indicators", ["cCarouselIndicators"], {}, {}, ["contentTemplates"], never, true, never>;
}
declare class CarouselItemComponent {
#private;
index?: number;
/**
* @ignore
*/
readonly activeInput: i0.InputSignalWithTransform<boolean, unknown>;
readonly active: i0.WritableSignal<boolean>;
/**
* Time delay before cycling to next item. If -1, uses carousel interval value.
* @return number
* @default -1
*/
readonly interval: i0.InputSignal<number>;
/**
* Carousel item role.
* @return string
* @default 'group'
*/
readonly role: i0.InputSignal<string>;
constructor();
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselItemComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselItemComponent, "c-carousel-item", ["cCarouselItem"], { "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class CarouselInnerComponent implements AfterContentInit, AfterContentChecked {
#private;
readonly activeIndex: i0.WritableSignal<number | undefined>;
readonly animate: i0.WritableSignal<boolean>;
readonly interval: i0.WritableSignal<number>;
readonly slide: i0.WritableSignal<{
left: boolean;
}>;
readonly transition: i0.WritableSignal<string>;
readonly slideType: i0.Signal<{
left: boolean;
type: string;
}>;
readonly ariaLive: i0.Signal<"off" | "polite">;
readonly contentItems: i0.Signal<readonly CarouselItemComponent[]>;
ngAfterContentInit(): void;
ngAfterContentChecked(): void;
setItems(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselInnerComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<CarouselInnerComponent, "c-carousel-inner", never, {}, {}, ["contentItems"], ["*"], true, never>;
}
declare class CarouselConfig {
activeIndex: number;
animate: boolean;
direction: 'next' | 'prev';
interval?: number;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselConfig, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<CarouselConfig>;
}
declare class CarouselModule {
static forRoot(): ModuleWithProviders<CarouselModule>;
static ɵfac: i0.ɵɵFactoryDeclaration<CarouselModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<CarouselModule, never, [typeof CarouselComponent, typeof CarouselCaptionComponent, typeof CarouselControlComponent, typeof CarouselIndicatorsComponent, typeof CarouselInnerComponent, typeof CarouselItemComponent], [typeof CarouselComponent, typeof CarouselCaptionComponent, typeof CarouselControlComponent, typeof CarouselIndicatorsComponent, typeof CarouselInnerComponent, typeof CarouselItemComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<CarouselModule>;
}
declare class CollapseDirective implements OnDestroy {
#private;
constructor();
/**
* @ignore
*/
readonly animateInput: i0.InputSignalWithTransform<boolean, unknown>;
readonly animate: i0.WritableSignal<boolean>;
/**
* Set horizontal collapsing to transition the width instead of height.
* @type boolean
* @default false
*/
readonly horizontal: i0.InputSignalWithTransform<boolean, unknown>;
/**
* Toggle the visibility of collapsible element.
* @type boolean
* @default false
*/
readonly visibleInput: i0.InputSignalWithTransform<boolean, unknown>;
readonly visibleChange: i0.OutputEmitterRef<boolean>;
readonly visible: i0.WritableSignal<boolean>;
/**
* Add `navbar` prop for grouping and hiding navbar contents by a parent breakpoint.
* @type boolean
* @default false
*/
readonly navbar: i0.InputSignalWithTransform<boolean, unknown>;
/**
* @ignore
*/
readonly duration: i0.InputSignal<string>;
/**
* @ignore
*/
readonly transition: i0.InputSignal<string>;
/**
* Event emitted on visibility change. [docs]
* @type string
*/
readonly collapseChange: i0.OutputEmitterRef<string>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
ngOnDestroy(): void;
toggle(visible?: boolean): void;
destroyPlayer(): void;
createPlayer(visible?: boolean): void;
setMaxSize(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<CollapseDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseDirective, "[cCollapse]", ["cCollapse"], { "animateInput": { "alias": "animate"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; "navbar": { "alias": "navbar"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "transition": { "alias": "transition"; "required": false; "isSignal": true; }; }, { "visibleChange": "visibleChange"; "collapseChange": "collapseChange"; }, never, never, true, never>;
}
declare class CollapseModule {
static forRoot(): ModuleWithProviders<CollapseModule>;
static ɵfac: i0.ɵɵFactoryDeclaration<CollapseModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<CollapseModule, never, [typeof CollapseDirective], [typeof CollapseDirective]>;
static ɵinj: i0.ɵɵInjectorDeclaration<CollapseModule>;
}
declare class DropdownDividerDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDividerDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownDividerDirective, "[cDropdownDivider]", never, {}, {}, never, never, true, never>;
}
declare class DropdownHeaderDirective {
static ɵfac: i0.ɵɵFactoryDeclaration<DropdownHeaderDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownHeaderDirective, "[cDropdownHeader]", never, {}, {}, never, never, true, never>;
}
declare class DropdownMenuDirective implements OnInit, AfterContentInit {
#private;
readonly elementRef: ElementRef;
/**
* Set alignment of dropdown menu.
* @return 'start' | 'end'
*/
readonly alignment: i0.InputSignal<string | undefined>;
/**
* Toggle the visibility of dropdown menu component.
* @return boolean
*/
readonly visibleInput: i0.InputSignalWithTransform<boolean, unknown>;
readonly visible: i0.WritableSignal<boolean>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
readonly hostStyles: i0.Signal<Record<string, any>>;
onKeyDown($event: KeyboardEvent): void;
onKeyUp($event: KeyboardEvent): void;
readonly dropdownItemsContent: i0.Signal<readonly DropdownItemDirective[]>;
readonly items$: rxjs.Observable<readonly DropdownItemDirective[]>;
ngAfterContentInit(): void;
ngOnInit(): void;
private focusKeyManagerInit;
static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownMenuDirective, "[cDropdownMenu]", ["cDropdownMenu"], { "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "visibleInput": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, ["dropdownItemsContent"], never, true, [{ directive: typeof ThemeDirective; inputs: { "dark": "dark"; }; outputs: {}; }]>;
}
interface IDropdownState {
visible?: boolean | 'toggle';
dropdown?: any;
}
declare class DropdownService {
private dropdownState;
dropdownState$: rxjs.Observable<any>;
toggle(state: IDropdownState): void;
static ɵfac: i0.ɵɵFactoryDeclaration<DropdownService, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<DropdownService>;
}
declare abstract class DropdownToken {
}
declare class DropdownToggleDirective implements AfterViewInit {
#private;
readonly elementRef: ElementRef<any>;
dropdown: DropdownToken | null;
/**
* Reference to dropdown component.
* @return DropdownComponent | undefined
* @default undefined
*/
readonly dropdownComponent: i0.InputSignal<DropdownComponent | undefined>;
/**
* Disables the toggler.
* @return boolean
* @default false
*/
readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
/**
* Enables pseudo element caret on toggler.
* @return boolean
*/
readonly caret: i0.InputSignal<boolean>;
/**
* Create split button dropdowns with virtually the same markup as single button dropdowns,
* but with the addition of `.dropdown-toggle-split` class for proper spacing around the dropdown caret.
* @return boolean
* @default false
*/
readonly split: i0.InputSignalWithTransform<boolean, unknown>;
readonly hostClasses: i0.Signal<Record<string, boolean>>;
get ariaExpanded(): boolean;
onClick($event: MouseEvent): void;
ngAfterViewInit(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<DropdownToggleDirective, never>;
static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownToggleDirective, "[cDropdownToggle]", ["cDropdownToggle"], { "dropdownComponent": { "alias": "dropdownComponent"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caret": { "alias": "caret"; "required": false; "isSignal": true; }; "split": { "alias": "split"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class DropdownComponent implements OnDestroy, OnInit {
#private;
readonly dropdownService: DropdownService;
constructor();
/**
* Set alignment of dropdown menu.
* @return {'start' | 'end' | { xs: 'start' | 'end' } | { sm: 'start' | 'end' } | { md: 'start' | 'end' } | { lg: 'start' | 'end' } | { xl: 'start' | 'end'} | { xxl: 'start' | 'end'}}
*/
readonly alignment: i0.InputSignal<string | undefined>;
/**
* Automatically close dropdown when clicking outside the dropdown menu.
*/
readonly autoClose: i0.InputSignal<boolean | "inside" | "outside">;
/**
* Sets a specified direction and location of the dropdown menu.
* @return 'dropup' | 'dropend' | 'dropstart'
*/
readonly direction: i0.InputSignal<"center" | "dropup" | "dropup-center" | "dropend" | "dropstart" | undefined>;
/**
* Describes the placement of your component after Popper.js has applied all the modifiers
* that may have flipped or altered the originally provided placement property.
* @return Placement
*/
readonly placement: i0.InputSignal<Placement>;
/**
* If you want to disable dynamic positioning