@cuby-ui/core 0.0.487 → 0.0.488

package/animations/animations.d.ts

@@ -0,0 +1,36 @@
+export interface CuiDurationOptions {
+    params: {
+        duration: number;
+    };
+    value: string;
+}
+/**
+ * Add to enable child :leave animation (fixes https://github.com/angular/angular/issues/15753)
+ */
+export declare const cuiParentAnimation: import("@angular/animations").AnimationTriggerMetadata;
+/**
+ * Add on parent to stop initial :enter animation for children
+ */
+export declare const cuiParentStop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHost: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHeightCollapse: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHeightCollapseList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiWidthCollapse: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiWidthCollapseList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInTop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInBottom: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiDropdownAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiScaleIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiPop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiScaleInList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInLeft: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInLeftList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInRight: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInRightList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInTop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInTopList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInBottom: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInBottomList: import("@angular/animations").AnimationTriggerMetadata;

package/animations/index.d.ts

@@ -0,0 +1 @@
+export * from './animations';

package/classes/accessors.d.ts

@@ -0,0 +1,17 @@
+import type { AbstractType, ExistingProvider, FactoryProvider, Type } from '@angular/core';
+import type { CuiPoint } from '../types';
+export declare abstract class CuiAccessor {
+    abstract readonly type: string;
+}
+export declare abstract class CuiPositionAccessor extends CuiAccessor {
+    abstract getPosition(rect: DOMRect, element?: HTMLElement): CuiPoint;
+}
+export declare abstract class CuiRectAccessor extends CuiAccessor {
+    abstract getClientRect(): DOMRect;
+}
+export declare function cuiProvideAccessor<T extends CuiAccessor>(provide: AbstractType<T>, type: string, fallback: Type<T>): FactoryProvider;
+export declare function cuiFallbackAccessor<T extends CuiAccessor>(type: string): (accessors: readonly T[] | null, fallback: T) => T;
+export declare function cuiPositionAccessorFor(type: string, fallback: Type<CuiPositionAccessor>): FactoryProvider;
+export declare function cuiRectAccessorFor(type: string, fallback: Type<CuiRectAccessor>): FactoryProvider;
+export declare function cuiAsPositionAccessor(accessor: Type<CuiPositionAccessor>): ExistingProvider;
+export declare function cuiAsRectAccessor(accessor: Type<CuiRectAccessor>): ExistingProvider;

package/classes/driver.d.ts

@@ -0,0 +1,16 @@
+import type { AfterViewInit, ExistingProvider, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class CuiDriver extends Observable<boolean> {
+    abstract readonly type: string;
+}
+export declare function cuiAsDriver(driver: Type<CuiDriver>): ExistingProvider;
+export declare abstract class CuiDriverDirective implements AfterViewInit {
+    abstract type: string;
+    private readonly destroyRef;
+    private readonly drivers;
+    private readonly vehicles;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDriverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiDriverDirective, never, never, {}, {}, never, never, false, never>;
+}

package/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './accessors';
+export * from './driver';
+export * from './vehicle';

package/classes/vehicle.d.ts

@@ -0,0 +1,6 @@
+import type { ExistingProvider, Type } from '@angular/core';
+export declare abstract class CuiVehicle {
+    abstract readonly type: string;
+    abstract toggle(value: boolean): void;
+}
+export declare function cuiAsVehicle(vehicle: Type<CuiVehicle>): ExistingProvider;

package/components/accordion/accordion-item/accordion-item.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import type { CuiIcon } from '@cuby-ui/icons';
+import { CuiAccordionAppearance } from './accordion-item.options';
+import * as i0 from "@angular/core";
+export declare class CuiAccordionItemComponent {
+    isOpen: boolean;
+    appearance: CuiAccordionAppearance;
+    readonly isOpenChange: EventEmitter<boolean>;
+    protected get buttonIcon(): CuiIcon;
+    get _appearance(): string;
+    protected onRowToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAccordionItemComponent, "cui-accordion-item", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, ["*", "[cuiAccordionItemContent]"], false, never>;
+}

package/components/accordion/accordion-item/accordion-item.options.d.ts

@@ -0,0 +1 @@
+export type CuiAccordionAppearance = 'border' | 'default';

package/components/accordion/accordion.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CuiAccordionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAccordionComponent, "cui-accordion", never, {}, {}, never, ["cui-accordion-item"], false, never>;
+}

package/components/accordion/accordion.directive.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class CuiAccordionDirective {
+    private readonly renderer;
+    private wrapper;
+    readonly content: import("@angular/core").InputSignal<HTMLElement>;
+    readonly isOpen: import("@angular/core").ModelSignal<boolean>;
+    constructor();
+    protected onToggle(event: Event): void;
+    private initWrapperEffect;
+    private initOpenChangesEffect;
+    private open;
+    private close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAccordionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiAccordionDirective, "[cuiAccordion]", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, never, never, true, never>;
+}

package/components/accordion/accordion.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./accordion.component";
+import * as i2 from "./accordion-item/accordion-item.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../svg/svg.module";
+import * as i5 from "../button/button.module";
+export declare class CuiAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiAccordionModule, [typeof i1.CuiAccordionComponent, typeof i2.CuiAccordionItemComponent], [typeof i3.CommonModule, typeof i4.CuiSvgModule, typeof i5.CuiButtonModule], [typeof i1.CuiAccordionComponent, typeof i2.CuiAccordionItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiAccordionModule>;
+}

package/components/accordion/index.d.ts

@@ -0,0 +1,4 @@
+export { CuiAccordionComponent } from './accordion.component';
+export { CuiAccordionDirective } from './accordion.directive';
+export { CuiAccordionModule } from './accordion.module';
+export { CuiAccordionItemComponent } from './accordion-item/accordion-item.component';

package/components/alert/alert.component.d.ts

@@ -0,0 +1,13 @@
+import type { OnInit } from '@angular/core';
+import type { CuiAlertResizing } from './alert.types';
+import * as i0 from "@angular/core";
+export declare class CuiAlertComponent implements OnInit {
+    protected readonly context: import("@cuby-ui/cdk").CuiPopover<import("@cuby-ui/core").CuiAlertOptions>;
+    protected readonly AUTO_CLOSE_DURATION_IN_MILLISECONDS = 3000;
+    protected get resizing(): CuiAlertResizing;
+    ngOnInit(): void;
+    protected onClosed(): void;
+    private initAutoClose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAlertComponent, "cui-alert", never, {}, {}, never, never, false, never>;
+}

package/components/alert/alert.interfaces.d.ts

@@ -0,0 +1,9 @@
+import type { CuiAlertPosition, CuiAlertResizing } from './alert.types';
+import type { CuiNotificationOptions } from '../notification';
+export interface CuiAlertOptions extends CuiNotificationOptions {
+    readonly label: string;
+    readonly needAutoClose: boolean;
+    readonly isCloseable: boolean;
+    readonly position: CuiAlertPosition;
+    readonly resizing: CuiAlertResizing;
+}

package/components/alert/alert.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./alert.component";
+import * as i2 from "./alerts.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@cuby-ui/cdk";
+import * as i5 from "../notification/notification.module";
+export declare class CuiAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiAlertModule, [typeof i1.CuiAlertComponent, typeof i2.CuiAlertsComponent], [typeof i3.CommonModule, typeof i4.CuiFilterPipe, typeof i5.CuiNotificationModule, typeof i4.CuiLetDirective], [typeof i1.CuiAlertComponent, typeof i1.CuiAlertComponent, typeof i2.CuiAlertsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiAlertModule>;
+}

package/components/alert/alert.service.d.ts

@@ -0,0 +1,7 @@
+import { CuiPopoverService } from '@cuby-ui/cdk';
+import type { CuiAlertOptions } from './alert.interfaces';
+import * as i0 from "@angular/core";
+export declare class CuiAlertService extends CuiPopoverService<CuiAlertOptions> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiAlertService>;
+}

package/components/alert/alert.tokens.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken } from '@angular/core';
+import { CuiPopover } from '@cuby-ui/cdk';
+import { BehaviorSubject } from 'rxjs';
+import type { CuiAlertOptions } from './alert.interfaces';
+export declare const CUI_ALERTS: InjectionToken<BehaviorSubject<readonly CuiPopover<CuiAlertOptions>[]>>;
+export declare const CUI_ALERT_DEFAULT_OPTIONS: Omit<CuiAlertOptions, 'status'>;
+export declare const CUI_ALERT_OPTIONS: InjectionToken<{
+    status: import("@cuby-ui/core").CuiStatus;
+    mode: "default" | "light";
+    label: string;
+    needAutoClose: boolean;
+    isCloseable: boolean;
+    position: import("@cuby-ui/core").CuiAlertPosition;
+    resizing: import("@cuby-ui/core").CuiAlertResizing;
+}>;
+export declare const CUI_ALERT_CONTEXT: InjectionToken<CuiPopover<CuiAlertOptions>>;

package/components/alert/alert.types.d.ts

@@ -0,0 +1,3 @@
+import type { CuiPositionCenter, CuiPositionRight, CuiResizingFixed, CuiResizingHug, CuiResizingStretch } from '../../types';
+export type CuiAlertPosition = CuiPositionCenter | CuiPositionRight;
+export type CuiAlertResizing = CuiResizingHug | CuiResizingFixed | CuiResizingStretch;

package/components/alert/alerts.component.d.ts

@@ -0,0 +1,17 @@
+import type { OnInit } from '@angular/core';
+import { Injector } from '@angular/core';
+import type { CuiPopover } from '@cuby-ui/cdk';
+import type { Observable } from 'rxjs';
+import type { CuiAlertOptions } from './alert.interfaces';
+import * as i0 from "@angular/core";
+export declare class CuiAlertsComponent implements OnInit {
+    private readonly destroy$;
+    protected readonly alerts$: Observable<ReadonlyArray<CuiPopover<CuiAlertOptions>>>;
+    protected alertInjectors: ReadonlyArray<Injector>;
+    ngOnInit(): void;
+    protected trackByFn(_: number, alert: CuiPopover<CuiAlertOptions>): string;
+    protected alertsMatcher(alert: CuiPopover<CuiAlertOptions>, position: string): boolean;
+    protected initAlertInjectorsSubscription(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiAlertsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAlertsComponent, "cui-alerts", never, {}, {}, never, never, false, never>;
+}

package/components/alert/index.d.ts

@@ -0,0 +1,8 @@
+export * from './alert.component';
+export * from './alert.interfaces';
+export * from './alert.module';
+export * from './alert.service';
+export * from './alert.tokens';
+export * from './alert.types';
+export * from './alert.component';
+export * from './alerts.component';

package/components/alert-hint/alert-hint.component.d.ts

@@ -0,0 +1,11 @@
+import { ErrorStatus } from './error-status';
+import * as i0 from "@angular/core";
+export declare class AlertHintComponent {
+    private readonly DEFAULT_TOOLTIP_TEXT;
+    protected readonly IconColor: Record<ErrorStatus, string>;
+    protected readonly iconColor: import("@angular/core").Signal<string>;
+    readonly status: import("@angular/core").InputSignal<ErrorStatus>;
+    readonly tooltipText: import("@angular/core").InputSignalWithTransform<string, string | string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertHintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertHintComponent, "cui-alert-hint", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "tooltipText": { "alias": "tooltipText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/alert-hint/error-status.d.ts

@@ -0,0 +1 @@
+export type ErrorStatus = 'warning' | 'error';

package/components/alert-hint/index.d.ts

@@ -0,0 +1,2 @@
+export { AlertHintComponent } from './alert-hint.component';
+export { ErrorStatus } from './error-status';

package/components/badge/badge.component.d.ts

@@ -0,0 +1,10 @@
+import type { CuiBadgeOptions } from './badge.options';
+import * as i0 from "@angular/core";
+export declare class CuiBadgeComponent implements CuiBadgeOptions {
+    private readonly options;
+    color: import("./badge.options").CuiBadgeColor;
+    size: "sm" | "md";
+    isWithDot: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBadgeComponent, "cui-badge", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isWithDot": { "alias": "isWithDot"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/components/badge/badge.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./badge.component";
+import * as i2 from "@angular/common";
+export declare class CuiBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiBadgeModule, [typeof i1.CuiBadgeComponent], [typeof i2.CommonModule], [typeof i1.CuiBadgeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiBadgeModule>;
+}

package/components/badge/badge.options.d.ts

@@ -0,0 +1,12 @@
+import type { CuiSizeMd, CuiSizeSm } from '../../types';
+export interface CuiBadgeOptions {
+    readonly color: CuiBadgeColor;
+    readonly size: CuiSizeSm | CuiSizeMd;
+    readonly isWithDot: boolean;
+}
+export type CuiBadgeColor = CuiBadgeColorSolid | CuiBadgeColorLight | CuiDeprecationColors;
+export type CuiBadgeColorSolid = 'violet-solid' | 'yellow-solid' | 'orange-solid' | 'lavender-solid' | 'magenta-solid' | 'green-solid' | 'black-solid' | 'red-solid' | 'blue-solid' | 'success-solid';
+export type CuiBadgeColorLight = 'gray' | 'dark-gray' | 'blue-light' | 'yellow-light' | 'green-light' | 'red-light' | 'lavender-light' | 'magenta-light' | 'violet-light' | 'orange-light';
+export type CuiDeprecationColors = 'light-blue' | 'yellow' | 'green' | 'red' | 'violet' | 'orange';
+export declare const CUI_BADGE_DEFAULT_OPTIONS: CuiBadgeOptions;
+export declare const CUI_BADGE_OPTIONS: import("@angular/core").InjectionToken<CuiBadgeOptions>;

package/components/badge/index.d.ts

@@ -0,0 +1,3 @@
+export * from './badge.component';
+export * from './badge.module';
+export { CuiBadgeColor, CuiBadgeOptions } from './badge.options';

package/components/banner/banner.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import type { CuiBannerIconOptions, CuiBannerOptions } from './banner.options';
+import type { CuiTheme } from '../../services';
+import { CuiThemeService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class CuiBannerComponent implements CuiBannerOptions {
+    private readonly options;
+    protected readonly theme$: CuiThemeService;
+    protected readonly ICON_OPTIONS: CuiBannerIconOptions;
+    protected readonly THEME_CLOSE_BUTTON_ICON_COLORS: Record<CuiTheme, string>;
+    status: import("@cuby-ui/core").CuiStatus;
+    isCloseable: boolean;
+    label?: string;
+    actionButtonText?: string;
+    actionButtonClicked: EventEmitter<void>;
+    closed: EventEmitter<void>;
+    protected onAction(): void;
+    protected onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBannerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBannerComponent, "cui-banner", never, { "status": { "alias": "status"; "required": false; }; "isCloseable": { "alias": "isCloseable"; "required": false; }; "label": { "alias": "label"; "required": false; }; "actionButtonText": { "alias": "actionButtonText"; "required": false; }; }, { "actionButtonClicked": "actionButtonClicked"; "closed": "closed"; }, never, ["*"], false, never>;
+}

package/components/banner/banner.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./banner.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@cuby-ui/cdk";
+import * as i4 from "../svg/svg.module";
+import * as i5 from "../button/button.module";
+export declare class CuiBannerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBannerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiBannerModule, [typeof i1.CuiBannerComponent], [typeof i2.CommonModule, typeof i3.CuiLetDirective, typeof i4.CuiSvgModule, typeof i5.CuiButtonModule], [typeof i1.CuiBannerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiBannerModule>;
+}

package/components/banner/banner.options.d.ts

@@ -0,0 +1,13 @@
+import type { CuiStatus } from '../../types';
+import type { CuiIcon } from '@cuby-ui/icons';
+export type CuiBannerIconOptions = {
+    [k in CuiStatus]: {
+        icon: CuiIcon;
+        color: string;
+    };
+};
+export interface CuiBannerOptions {
+    readonly status: CuiStatus;
+}
+export declare const CUI_BANNER_DEFAULT_OPTIONS: CuiBannerOptions;
+export declare const CUI_BANNER_OPTIONS: import("@angular/core").InjectionToken<CuiBannerOptions>;

package/components/banner/index.d.ts

@@ -0,0 +1,3 @@
+export * from './banner.component';
+export * from './banner.module';
+export * from './banner.options';

package/components/breadcrumbs/breadcrumb/breadcrumb.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class CuiBreadcrumbComponent {
+    isLast: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBreadcrumbComponent, "[cuiBreadcrumb]", never, { "isLast": { "alias": "isLast"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/components/breadcrumbs/breadcrumbs.component.d.ts

@@ -0,0 +1,7 @@
+import { QueryList, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CuiBreadcrumbsComponent {
+    protected readonly breadcrumbs: QueryList<TemplateRef<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBreadcrumbsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBreadcrumbsComponent, "cui-breadcrumbs", never, {}, {}, ["breadcrumbs"], never, false, never>;
+}

package/components/breadcrumbs/breadcrumbs.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./breadcrumbs.component";
+import * as i2 from "./breadcrumb/breadcrumb.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../svg/svg.module";
+export declare class CuiBreadcrumbsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiBreadcrumbsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiBreadcrumbsModule, [typeof i1.CuiBreadcrumbsComponent, typeof i2.CuiBreadcrumbComponent], [typeof i3.CommonModule, typeof i4.CuiSvgModule], [typeof i1.CuiBreadcrumbsComponent, typeof i2.CuiBreadcrumbComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiBreadcrumbsModule>;
+}

package/components/breadcrumbs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './breadcrumbs.component';
+export * from './breadcrumbs.module';
+export * from './breadcrumb/breadcrumb.component';

package/components/button/button.component.d.ts

@@ -0,0 +1,39 @@
+import { ElementRef, OnInit } from '@angular/core';
+import type { CuiIcon } from '@cuby-ui/icons';
+import { CuiButtonAppearance, CuiButtonOptions, CuiButtonSize, CuiButtonTheme } from './button.options';
+import * as i0 from "@angular/core";
+export declare class CuiButtonComponent implements CuiButtonOptions, OnInit {
+    private readonly changeDetectorRef;
+    private readonly cuiButtonOptions;
+    private readonly ICON_XS_SIZES;
+    protected readonly COLOR_BASE_500 = "var(--cui-base-500)";
+    protected readonly BUTTON_ICONS_COLOR_BASE_500: CuiButtonAppearance[];
+    protected _theme: CuiButtonTheme;
+    protected _appearance: CuiButtonAppearance;
+    protected _size: CuiButtonSize;
+    protected iconColor: string;
+    protected iconDimensions: {
+        width: number;
+        height: number;
+    };
+    shape: import("./button.options").CuiButtonShape;
+    disabled: boolean;
+    isLoaderShown: boolean;
+    icon?: CuiIcon | string;
+    iconRight?: CuiIcon | string;
+    get appearance(): CuiButtonAppearance;
+    set appearance(appearance: CuiButtonAppearance);
+    get theme(): CuiButtonTheme;
+    set theme(theme: CuiButtonTheme);
+    get size(): CuiButtonSize;
+    set size(size: CuiButtonSize);
+    protected containsOnlyIcon: boolean;
+    protected get isDisabled(): boolean;
+    protected content: ElementRef<HTMLSpanElement>;
+    ngOnInit(): void;
+    private initIconColor;
+    private changeIconColor;
+    private getIconColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiButtonComponent, "button[cuiButton], a[cuiButton]", never, { "shape": { "alias": "shape"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isLoaderShown": { "alias": "isLoaderShown"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconRight": { "alias": "iconRight"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/components/button/button.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../svg/svg.module";
+export declare class CuiButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiButtonModule, [typeof i1.CuiButtonComponent], [typeof i2.CommonModule, typeof i3.CuiSvgModule], [typeof i1.CuiButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiButtonModule>;
+}

package/components/button/button.options.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken } from '@angular/core';
+import type { CuiAppearanceAction, CuiAppearanceActionCyan, CuiAppearanceActionViolet, CuiAppearanceDestructive, CuiAppearanceFlat, CuiAppearanceGhost, CuiAppearanceLink, CuiAppearanceOutlined, CuiAppearanceOutlinedGray, CuiAppearanceSecondary, CuiAppearanceVividSuccess, CuiButtonThemeCyan, CuiButtonThemeDefault, CuiButtonThemeSuccess, CuiButtonThemeViolet, CuiButtonThemeVividSuccess, CuiShapeRounded, CuiSizeLg, CuiSizeMd, CuiSizeSm, CuiSizeXs, CuiSizeXxs, CuiSizeXxxs } from '../../types';
+export interface CuiButtonOptions {
+    readonly appearance: CuiButtonAppearance;
+    readonly shape: CuiButtonShape;
+    readonly size: CuiButtonSize;
+    readonly theme: CuiButtonTheme;
+}
+export type CuiButtonAppearance = CuiAppearanceAction | CuiAppearanceSecondary | CuiAppearanceOutlined | CuiAppearanceOutlinedGray | CuiAppearanceGhost | CuiAppearanceFlat | CuiAppearanceVividSuccess | CuiAppearanceDestructive | CuiAppearanceLink | CuiAppearanceActionViolet | CuiAppearanceActionCyan;
+export type CuiButtonTheme = CuiButtonThemeDefault | CuiButtonThemeViolet | CuiButtonThemeCyan | CuiButtonThemeSuccess | CuiButtonThemeVividSuccess;
+export type CuiButtonSize = CuiSizeXxxs | CuiSizeXxs | CuiSizeXs | CuiSizeSm | CuiSizeMd | CuiSizeLg;
+export type CuiButtonShape = CuiShapeRounded | null;
+export declare const CUI_BUTTON_DEFAULT_OPTIONS: CuiButtonOptions;
+export declare const CUI_BUTTON_OPTIONS: InjectionToken<CuiButtonOptions>;

package/components/button/index.d.ts

@@ -0,0 +1,3 @@
+export * from './button.component';
+export * from './button.module';
+export * from './button.options';

package/components/button-group/button-group.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CuiButtonGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiButtonGroupComponent, "cui-button-group", never, {}, {}, never, ["button[cuiButton], a[cuiButton]"], false, never>;
+}

package/components/button-group/button-group.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button-group.component";
+export declare class CuiButtonGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiButtonGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiButtonGroupModule, [typeof i1.CuiButtonGroupComponent], never, [typeof i1.CuiButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiButtonGroupModule>;
+}

package/components/button-group/index.d.ts

@@ -0,0 +1,2 @@
+export * from './button-group.component';
+export * from './button-group.module';

package/components/card-wrapper/card-wrapper.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class CuiCardWrapperComponent {
+    readonly withBorder: import("@angular/core").InputSignal<boolean>;
+    readonly isSelected: import("@angular/core").InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCardWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCardWrapperComponent, "cui-card-wrapper, [cuiCardWrapper]", never, { "withBorder": { "alias": "withBorder"; "required": false; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/components/card-wrapper/index.d.ts

@@ -0,0 +1 @@
+export { CuiCardWrapperComponent } from './card-wrapper.component';

package/components/checkbox/checkbox.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CuiCheckboxComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiCheckboxComponent, "input[type=\"checkbox\"][cuiCheckbox]", never, {}, {}, never, never, false, never>;
+}

package/components/checkbox/checkbox.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./checkbox.component";
+export declare class CuiCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiCheckboxModule, [typeof i1.CuiCheckboxComponent], never, [typeof i1.CuiCheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiCheckboxModule>;
+}

package/components/checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export * from './checkbox.component';
+export * from './checkbox.module';

package/components/content-header/content-header.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class ContentHeaderComponent {
+    readonly heading: import("@angular/core").InputSignal<string>;
+    readonly subheading: import("@angular/core").InputSignal<string | undefined>;
+    readonly tooltip: import("@angular/core").InputSignal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentHeaderComponent, "header[cuiContentHeader]", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "subheading": { "alias": "subheading"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/components/content-header/index.d.ts

@@ -0,0 +1 @@
+export { ContentHeaderComponent } from './content-header.component';

package/components/content-wrapper/content-wrapper.component.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class CuiContentWrapperComponent {
+    private readonly DEFAULT_BACKGROUND_COLOR;
+    private readonly DEFAULT_GAP;
+    readonly backgroundColor: import("@angular/core").InputSignal<string>;
+    readonly gap: import("@angular/core").InputSignal<number>;
+    protected get _backgroundColor(): string;
+    protected get _gap(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiContentWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiContentWrapperComponent, "cui-content-wrapper, [cuiContentWrapper]", never, { "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/components/content-wrapper/index.d.ts

@@ -0,0 +1 @@
+export * from './content-wrapper.component';

package/components/context-menu/context-menu.component.d.ts

@@ -0,0 +1,41 @@
+import type { OnInit, AfterViewInit, TemplateRef, OnDestroy } from '@angular/core';
+import type { CuiContextMenuItem } from '../../interfaces';
+import * as i0 from "@angular/core";
+import * as i1 from "@cuby-ui/cdk";
+export declare class CuiContextMenuComponent implements OnInit, AfterViewInit, OnDestroy {
+    private readonly viewContainerRef;
+    private readonly document;
+    private readonly documentElement;
+    private readonly window;
+    private readonly destroy$;
+    private readonly cuiClickOutsideDirective;
+    private readonly cuiTargetDirective;
+    protected readonly EXTRA_OFFSET_LEFT = 0;
+    protected readonly EXTRA_OFFSET_TOP = 0;
+    protected isVisible: boolean;
+    protected node?: HTMLDivElement;
+    items: CuiContextMenuItem[];
+    target: HTMLElement;
+    width: string;
+    withPaddings: boolean;
+    protected readonly list: TemplateRef<any>;
+    protected readonly backdrop: TemplateRef<any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    protected onSelect(item: CuiContextMenuItem): void;
+    protected onClose(): void;
+    protected onStopClickPropagation(event: MouseEvent): void;
+    protected trackByFn(_: number, item: CuiContextMenuItem): string;
+    private initClickOutsideSubscription;
+    private initTargetElementListener;
+    private initHidingSubscription;
+    private initHidingFromWindowEvent;
+    private targetEventListener;
+    private close;
+    private renderList;
+    private changePosition;
+    private clearViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiContextMenuComponent, "cui-context-menu[items][target]", never, { "items": { "alias": "items"; "required": false; }; "target": { "alias": "target"; "required": false; }; "width": { "alias": "width"; "required": false; }; "withPaddings": { "alias": "withPaddings"; "required": false; }; }, {}, never, never, false, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.CuiTargetDirective; inputs: { "ccTarget": "target"; }; outputs: {}; }]>;
+}