@ardium-pl/ui 5.0.0-alpha.106

package/lib/_internal/selectable-list-component.d.ts

@@ -0,0 +1,76 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { ArdFormFieldControl } from '../form-field/form-field-child.token';
+import { ArdOptionSimple, CompareWithFn, OptionContext } from '../types/item-storage.types';
+import { Nullable } from '../types/utility.types';
+import { _FormFieldComponentBase, _FormFieldComponentDefaults } from './form-field-component';
+import { SimpleItemStorage, SimpleItemStorageHost } from './item-storages/simple-item-storage';
+import * as i0 from "@angular/core";
+export interface _SelectableListComponentDefaults extends _FormFieldComponentDefaults {
+    valueFrom: string;
+    labelFrom: string;
+    disabledFrom: string;
+    compareWith: Nullable<CompareWithFn>;
+    multiselectable: boolean;
+    requireValue: boolean;
+    invertDisabled: boolean;
+    maxSelectedItems: Nullable<number>;
+}
+export declare const _selectableListComponentDefaults: _SelectableListComponentDefaults;
+export declare abstract class _SelectableListComponentBase extends _FormFieldComponentBase implements ControlValueAccessor, SimpleItemStorageHost, ArdFormFieldControl {
+    protected readonly _DEFAULTS: _SelectableListComponentDefaults;
+    readonly itemStorage: SimpleItemStorage;
+    readonly element: HTMLElement;
+    readonly DEFAULTS: _SelectableListComponentDefaults;
+    abstract readonly _componentId: string;
+    abstract readonly _componentName: string;
+    private readonly _cd;
+    readonly valueFrom: import("@angular/core").InputSignal<string>;
+    readonly labelFrom: import("@angular/core").InputSignal<string>;
+    readonly disabledFrom: import("@angular/core").InputSignal<string>;
+    readonly compareWith: import("@angular/core").InputSignal<Nullable<CompareWithFn>>;
+    get items(): any[];
+    set items(value: any);
+    readonly multiselectable: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    get _multiselectableHostAttribute(): boolean;
+    readonly singleselectable: import("@angular/core").Signal<boolean>;
+    readonly requireValue: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly isValueRequired: import("@angular/core").Signal<boolean>;
+    get _requireValueHostAttribute(): boolean;
+    readonly invertDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly maxSelectedItems: import("@angular/core").InputSignalWithTransform<Nullable<number>, any>;
+    setDisabledState(state: boolean): void;
+    writeValue(ngModel: any[]): void;
+    readonly touched: import("@angular/core").WritableSignal<boolean>;
+    get _touchedHostAttribute(): boolean;
+    protected _emitChange(): void;
+    protected _onTouched(): void;
+    private readonly lastBlurTimestamp;
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    readonly highlightedItems: import("@angular/core").Signal<ArdOptionSimple[]>;
+    readonly firstHighlightedItem: import("@angular/core").Signal<Nullable<ArdOptionSimple>>;
+    readonly isItemLimitReached: import("@angular/core").Signal<boolean>;
+    readonly optionContextGenerator: import("@angular/core").Signal<(item: ArdOptionSimple) => OptionContext<ArdOptionSimple>>;
+    set value(newValue: any);
+    readonly valueChange: import("@angular/core").OutputEmitterRef<any>;
+    readonly addEvent: import("@angular/core").OutputEmitterRef<any[]>;
+    readonly removeEvent: import("@angular/core").OutputEmitterRef<any[]>;
+    toggleItem(item: ArdOptionSimple): void;
+    selectItem(...items: ArdOptionSimple[]): void;
+    unselectItem(...items: ArdOptionSimple[]): void;
+    readonly isMouseBeingUsed: import("@angular/core").WritableSignal<boolean>;
+    onMouseMove(): void;
+    onItemMouseEnter(option: ArdOptionSimple, event: MouseEvent): void;
+    onItemMouseLeave(option: ArdOptionSimple, event: MouseEvent): void;
+    onItemClick(option: ArdOptionSimple, event: MouseEvent): void;
+    onKeyPress(event: KeyboardEvent): void;
+    private _toggleHighlightedItems;
+    private _highlightPrevious;
+    private _highlightNext;
+    private _highlightFirst;
+    private _highlightLast;
+    private _highlightAll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_SelectableListComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_SelectableListComponentBase, never, never, { "valueFrom": { "alias": "valueFrom"; "required": false; "isSignal": true; }; "labelFrom": { "alias": "labelFrom"; "required": false; "isSignal": true; }; "disabledFrom": { "alias": "disabledFrom"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; }; "multiselectable": { "alias": "multiselectable"; "required": false; "isSignal": true; }; "requireValue": { "alias": "requireValue"; "required": false; "isSignal": true; }; "invertDisabled": { "alias": "invertDisabled"; "required": false; "isSignal": true; }; "maxSelectedItems": { "alias": "maxSelectedItems"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "addEvent": "add"; "removeEvent": "remove"; }, never, never, true, never>;
+}

package/lib/_internal/utils/context-to-inputs.d.ts

@@ -0,0 +1,3 @@
+import { Signal, Type } from '@angular/core';
+export declare function contextToInputs<T>(context: Signal<Record<string, any>>, component: Type<T> | undefined): Signal<Partial<T>>;
+export declare function contextToInputsMultiple<T, V>(context: Signal<(value: V) => Record<string, any>>, component: Type<T> | undefined): Signal<(value: V) => Partial<T>>;

package/lib/_internal/utils/date.utils.d.ts

@@ -0,0 +1,21 @@
+export declare function getUTCDate(): Date;
+export declare function getUTCDate(year: number, monthIndex: number, day: number): Date;
+export declare function getUTCDate(year: number, monthIndex: number, day: number, hour: number, minute: number, second: number, millisecond: number): Date;
+export declare function createDate(year: number, month: number, date: number, UTC: boolean): Date;
+export declare function getDateComponents(date: null, UTC: boolean): {
+    year: null;
+    month: null;
+    date: null;
+};
+export declare function getDateComponents(date: Date, UTC: boolean): {
+    year: number;
+    month: number;
+    date: number;
+};
+export declare function getDateComponents(date: Date | null, UTC: boolean): {
+    year: number | null;
+    month: number | null;
+    date: number | null;
+};
+export declare function startOfDay(date: Date, UTC?: boolean): Date;
+export declare function endOfDay(date: Date, UTC?: boolean): Date;

package/lib/badge/badge.defaults.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { ComponentColor } from './../types/colors.types';
+import { FormElementVariant } from './../types/theming.types';
+import { BadgePosition, BadgeSize } from './badge.types';
+export interface ArdBadgeDefaults {
+    color: ComponentColor;
+    variant: FormElementVariant;
+    size: BadgeSize;
+    position: BadgePosition;
+    overlap: boolean;
+}
+export declare const ARD_BADGE_DEFAULTS: InjectionToken<ArdBadgeDefaults>;
+export declare function provideBadgeDefaults(config: Partial<ArdBadgeDefaults>): Provider;

package/lib/badge/badge.directive.d.ts

@@ -0,0 +1,27 @@
+import { AfterViewInit, OnChanges, OnDestroy } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { ComponentColor } from '../types/colors.types';
+import { FormElementVariant } from '../types/theming.types';
+import { BadgePosition, BadgeSize } from './badge.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumBadgeDirective implements OnChanges, AfterViewInit, OnDestroy {
+    private readonly _elRef;
+    private readonly _renderer;
+    private readonly _DEFAULTS;
+    readonly text: import("@angular/core").InputSignal<string>;
+    readonly color: import("@angular/core").InputSignal<ComponentColor>;
+    readonly variant: import("@angular/core").InputSignal<FormElementVariant>;
+    readonly size: import("@angular/core").InputSignal<BadgeSize>;
+    readonly position: import("@angular/core").InputSignalWithTransform<BadgePosition, BadgePosition>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly overlap: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    private readonly _elementClasses;
+    private _createBadgeElement;
+    private readonly _badgeElement;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumBadgeDirective, "[ardBadge]", never, { "text": { "alias": "ardBadge"; "required": false; "isSignal": true; }; "color": { "alias": "ardBadgeColor"; "required": false; "isSignal": true; }; "variant": { "alias": "ardBadgeVariant"; "required": false; "isSignal": true; }; "size": { "alias": "ardBadgeSize"; "required": false; "isSignal": true; }; "position": { "alias": "ardBadgePosition"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ardBadgeAriaLabel"; "required": false; "isSignal": true; }; "hidden": { "alias": "ardBadgeHidden"; "required": false; "isSignal": true; }; "overlap": { "alias": "ardBadgeOverlap"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/badge/badge.module.d.ts

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

package/lib/badge/badge.types.d.ts

@@ -0,0 +1,17 @@
+export declare const BadgeSize: {
+    readonly Small: "small";
+    readonly Medium: "medium";
+    readonly Large: "large";
+};
+export type BadgeSize = (typeof BadgeSize)[keyof typeof BadgeSize];
+export declare const BadgePosition: {
+    readonly AboveBefore: "above-before";
+    readonly AboveAfter: "above-after";
+    readonly BelowBefore: "below-before";
+    readonly BelowAfter: "below-after";
+    readonly Before: "before";
+    readonly After: "after";
+    readonly Above: "above";
+    readonly Below: "below";
+};
+export type BadgePosition = (typeof BadgePosition)[keyof typeof BadgePosition];

package/lib/badge/index.d.ts

@@ -0,0 +1,4 @@
+export * from './badge.defaults';
+export * from './badge.directive';
+export * from './badge.module';
+export * from './badge.types';

package/lib/breakpoints/breakpoint.service.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ArdiumBreakpointService implements OnDestroy {
+    private readonly _destroyed;
+    readonly breakpointMap: Map<string, string>;
+    readonly breakpoints: string[];
+    readonly currentBreakpoint: import("@angular/core").WritableSignal<string | null>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumBreakpointService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArdiumBreakpointService>;
+}

package/lib/breakpoints/breakpoint.utils.d.ts

@@ -0,0 +1,7 @@
+import { ArdGridSize } from '../grid';
+import { ArdBreakpointsConfig } from './breakpoints';
+export declare function parseNumberOrBreakpointConfig(value: number | string | ArdBreakpointsConfig<number>, breakpoints: string[], componentId: string): Required<ArdBreakpointsConfig<number>>;
+export declare function parseSizeOrBreakpointConfig(value: number | ArdGridSize | string | ArdBreakpointsConfig<number | ArdGridSize>, breakpoints: string[], componentId: string): Required<ArdBreakpointsConfig<number | ArdGridSize>>;
+export declare function parseBooleanOrBreakpointConfig(value: boolean | string | ArdBreakpointsConfig<boolean>, breakpoints: string[], componentId: string): Required<ArdBreakpointsConfig<boolean>>;
+export declare function parseCSSUnitOrBreakpointConfig(value: null | number | string | ArdBreakpointsConfig<string | number>, breakpoints: string[], componentId: string): Required<ArdBreakpointsConfig<string>> | null;
+export declare function parseEnumOrBreakpointConfig<T>(value: T | string | ArdBreakpointsConfig<T>, breakpoints: string[], componentId: string, isEnumValue: (val: any) => val is T): Required<ArdBreakpointsConfig<T>>;

package/lib/breakpoints/breakpoints.d.ts

@@ -0,0 +1,13 @@
+export interface ArdBreakpointsConfig<T> {
+    xs?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+    '2xl'?: T;
+    [key: string]: T | undefined;
+}
+export type ArdBreakpoints = Required<ArdBreakpointsConfig<string>>;
+import { InjectionToken, Provider } from '@angular/core';
+export declare const ARD_BREAKPOINTS: InjectionToken<Map<string, string>>;
+export declare function provideBreakpoints(config?: Partial<ArdBreakpoints>): Provider[];

package/lib/breakpoints/index.d.ts

@@ -0,0 +1,2 @@
+export * from './breakpoint.service';
+export * from './breakpoints';

package/lib/buttons/_button-base.d.ts

@@ -0,0 +1,25 @@
+import { Signal } from '@angular/core';
+import { BooleanLike, NumberLike } from '@ardium-ui/devkit';
+import { ButtonType } from '../types/button.types';
+import { ComponentColor } from '../types/colors.types';
+import { _ButtonBaseDefaults } from './_button-base.defaults';
+import { ButtonAppearance } from './general-button.types';
+import * as i0 from "@angular/core";
+export declare abstract class _ButtonBase {
+    protected readonly _DEFAULTS: _ButtonBaseDefaults;
+    readonly wrapperClasses: import("@angular/core").InputSignal<string>;
+    constructor(_DEFAULTS: _ButtonBaseDefaults);
+    readonly type: import("@angular/core").InputSignal<ButtonType>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    readonly appearance: import("@angular/core").InputSignal<ButtonAppearance>;
+    readonly color: import("@angular/core").InputSignal<ComponentColor>;
+    readonly lightColoring: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly tabIndex: Signal<number>;
+    readonly _tabIndex: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly pointerEventsWhenDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    abstract readonly ngClasses: Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ButtonBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_ButtonBase, never, never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "lightColoring": { "alias": "lightColoring"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "pointerEventsWhenDisabled": { "alias": "pointerEventsWhenDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/buttons/_button-base.defaults.d.ts

@@ -0,0 +1,17 @@
+import { ButtonType } from '../types/button.types';
+import { ComponentColor } from './../types/colors.types';
+import { ButtonAppearance } from './general-button.types';
+export interface _SimpleButtonDefaults {
+    disabled: boolean;
+    tabIndex: number;
+    color: ComponentColor;
+    lightColoring: boolean;
+    compact: boolean;
+    type: ButtonType;
+    pointerEventsWhenDisabled: boolean;
+}
+export declare const _simpleButtonDefaults: _SimpleButtonDefaults;
+export interface _ButtonBaseDefaults extends _SimpleButtonDefaults {
+    appearance: ButtonAppearance;
+}
+export declare const _buttonBaseDefaults: _ButtonBaseDefaults;

package/lib/buttons/button/button.component.d.ts

@@ -0,0 +1,22 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _ButtonBase } from '../_button-base';
+import { ButtonVariant } from '../general-button.types';
+import { ArdButtonDefaults } from './button.defaults';
+import * as i0 from "@angular/core";
+export declare class ArdiumButtonComponent extends _ButtonBase implements OnChanges {
+    protected readonly _DEFAULTS: ArdButtonDefaults;
+    constructor(defaults: ArdButtonDefaults);
+    readonly focusEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    readonly blurEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    readonly variant: import("@angular/core").InputSignal<ButtonVariant>;
+    readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly square: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly inheritedCompact: import("@angular/core").WritableSignal<boolean | null>;
+    readonly wasCompactChanged: import("@angular/core").WritableSignal<boolean>;
+    readonly compactOrInherited: import("@angular/core").Signal<boolean>;
+    ngOnChanges(changes: SimpleChanges): void;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumButtonComponent, "ard-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "square": { "alias": "square"; "required": false; "isSignal": true; }; }, { "focusEvent": "focus"; "blurEvent": "blur"; }, never, ["*"], false, never>;
+}

package/lib/buttons/button/button.defaults.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { _ButtonBaseDefaults } from '../_button-base.defaults';
+import { ButtonVariant } from '../general-button.types';
+export interface ArdButtonDefaults extends _ButtonBaseDefaults {
+    variant: ButtonVariant;
+    vertical: boolean;
+    square: boolean;
+}
+export declare const ARD_BUTTON_DEFAULTS: InjectionToken<ArdButtonDefaults>;
+export declare function provideButtonDefaults(config: Partial<ArdButtonDefaults>): Provider;

package/lib/buttons/button/button.directive.d.ts

@@ -0,0 +1,23 @@
+import { SimpleChanges } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _ButtonBase } from '../_button-base';
+import { ButtonVariant } from '../general-button.types';
+import { ArdButtonDefaults } from './button.defaults';
+import * as i0 from "@angular/core";
+export declare class ArdiumButtonDirective extends _ButtonBase {
+    protected readonly _DEFAULTS: ArdButtonDefaults;
+    constructor(defaults: ArdButtonDefaults);
+    private readonly _hostEl;
+    private readonly _renderer;
+    handleClick(event: Event): void;
+    readonly variant: import("@angular/core").InputSignal<ButtonVariant>;
+    readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly square: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    readonly inheritedCompact: import("@angular/core").WritableSignal<boolean | null>;
+    readonly wasCompactChanged: import("@angular/core").WritableSignal<boolean>;
+    readonly compactOrInherited: import("@angular/core").Signal<boolean>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumButtonDirective, "button[ard-button], a[ard-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "square": { "alias": "square"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/buttons/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 "./button.directive";
+import * as i3 from "@angular/common";
+export declare class ArdiumButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumButtonModule, [typeof i1.ArdiumButtonComponent, typeof i2.ArdiumButtonDirective], [typeof i3.CommonModule], [typeof i1.ArdiumButtonComponent, typeof i2.ArdiumButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumButtonModule>;
+}

package/lib/buttons/button/index.d.ts

@@ -0,0 +1,4 @@
+export * from './button.component';
+export * from './button.defaults';
+export * from './button.directive';
+export * from './button.module';

package/lib/buttons/button-group/button-group.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterContentInit, SimpleChanges } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { ArdiumButtonComponent, ArdiumButtonDirective } from '../button';
+import * as i0 from "@angular/core";
+export declare class ArdiumButtonGroupComponent implements AfterContentInit {
+    private readonly _DEFAULTS;
+    readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly inheritedVertical: import("@angular/core").WritableSignal<boolean | null>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly inheritedCompact: import("@angular/core").WritableSignal<boolean | null>;
+    readonly wasVerticalChanged: import("@angular/core").WritableSignal<boolean>;
+    readonly wasCompactChanged: import("@angular/core").WritableSignal<boolean>;
+    readonly verticalOrInherited: import("@angular/core").Signal<boolean>;
+    readonly compactOrInherited: import("@angular/core").Signal<boolean>;
+    ngOnChanges(changes: SimpleChanges): void;
+    readonly groupChildren: import("@angular/core").Signal<readonly ArdiumButtonGroupComponent[]>;
+    readonly buttonChildren: import("@angular/core").Signal<readonly ArdiumButtonComponent[]>;
+    readonly buttonDirChildren: import("@angular/core").Signal<readonly ArdiumButtonDirective[]>;
+    constructor();
+    private _wasContentInitialized;
+    ngAfterContentInit(): void;
+    private _updateChildrenStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumButtonGroupComponent, "ard-button-group", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, ["groupChildren", "buttonChildren", "buttonDirChildren"], ["*"], false, never>;
+}

package/lib/buttons/button-group/button-group.defaults.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, Provider } from '@angular/core';
+export interface ArdButtonGroupDefaults {
+    vertical: boolean;
+    compact: boolean;
+}
+export declare const ARD_BUTTON_GROUP_DEFAULTS: InjectionToken<ArdButtonGroupDefaults>;
+export declare function provideButtonGroupDefaults(config: Partial<ArdButtonGroupDefaults>): Provider;

package/lib/buttons/button-group/button-group.module.d.ts

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

package/lib/buttons/button-group/index.d.ts

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

package/lib/buttons/fab/fab.component.d.ts

@@ -0,0 +1,13 @@
+import { _ButtonBase } from '../_button-base';
+import { FabSize } from '../general-button.types';
+import { ArdFabDefaults } from './fab.defaults';
+import * as i0 from "@angular/core";
+export declare class ArdiumFabComponent extends _ButtonBase {
+    constructor(defaults: ArdFabDefaults);
+    readonly focusEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    readonly blurEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    readonly size: import("@angular/core").InputSignal<FabSize>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumFabComponent, "ard-fab", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "focusEvent": "focus"; "blurEvent": "blur"; }, never, ["*"], false, never>;
+}

package/lib/buttons/fab/fab.defaults.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { _ButtonBaseDefaults } from '../_button-base.defaults';
+import { FabSize } from '../general-button.types';
+export interface ArdFabDefaults extends _ButtonBaseDefaults {
+    size: FabSize;
+}
+export declare const ARD_FAB_DEFAULTS: InjectionToken<ArdFabDefaults>;
+export declare function provideFabDefaults(config: Partial<ArdFabDefaults>): Provider;

package/lib/buttons/fab/fab.module.d.ts

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

package/lib/buttons/fab/index.d.ts

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

package/lib/buttons/general-button.types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * General button appearance. Controls which parts of the button can be colored.
+ *
+ * @see {@link ButtonColoringMode}
+ */
+export declare const ButtonAppearance: {
+    /**
+     * No border and no background. Text and icon are colored.
+     */
+    readonly Transparent: "transparent";
+    /**
+     * No border, but with text shadow. Text, icon, and background are colored.
+     */
+    readonly Raised: "raised";
+    /**
+     * No border, but with text shadow. White background. Text and icon are colored.
+     */
+    readonly RaisedStrong: "raised-strong";
+    /**
+     * White background. Text and icon are colored.
+     */
+    readonly Outlined: "outlined";
+    /**
+     * White background. Text, icon, and border may be colored.
+     *
+     * Background becomes colored on hover/focus.
+     */
+    readonly OutlinedStrong: "outlined-strong";
+    /**
+     * No border. Text, icon, and background are colored.
+     */
+    readonly Flat: "flat";
+};
+export type ButtonAppearance = (typeof ButtonAppearance)[keyof typeof ButtonAppearance];
+export declare const ButtonVariant: {
+    /**
+     * Basic, rectangular button.
+     */
+    readonly Rounded: "rounded";
+    /**
+     * Pill-shaped button.
+     */
+    readonly Pill: "pill";
+    /**
+     * Basic, rectangular button with sharp corners.
+     */
+    readonly Sharp: "sharp";
+};
+export type ButtonVariant = (typeof ButtonVariant)[keyof typeof ButtonVariant];
+/**
+ * **F**loating **A**ction **B**utton size.
+ */
+export declare const FabSize: {
+    readonly Standard: "standard";
+    readonly Small: "small";
+};
+export type FabSize = (typeof FabSize)[keyof typeof FabSize];

package/lib/buttons/icon-button/icon-button.component.d.ts

@@ -0,0 +1,20 @@
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _FocusableComponentBase } from '../../_internal/focusable-component';
+import { ButtonType } from '../../types/button.types';
+import { ComponentColor } from '../../types/colors.types';
+import { ArdIconButtonDefaults } from './icon-button.defaults';
+import * as i0 from "@angular/core";
+export declare class ArdiumIconButtonComponent extends _FocusableComponentBase {
+    protected readonly _DEFAULTS: ArdIconButtonDefaults;
+    constructor(defaults: ArdIconButtonDefaults);
+    readonly wrapperClasses: import("@angular/core").InputSignal<string>;
+    readonly type: import("@angular/core").InputSignal<ButtonType>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    readonly color: import("@angular/core").InputSignal<ComponentColor>;
+    readonly lightColoring: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly pointerEventsWhenDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumIconButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumIconButtonComponent, "ard-icon-button", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "lightColoring": { "alias": "lightColoring"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "pointerEventsWhenDisabled": { "alias": "pointerEventsWhenDisabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}

package/lib/buttons/icon-button/icon-button.defaults.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { _FocusableComponentDefaults } from '../../_internal/focusable-component';
+import { _SimpleButtonDefaults } from '../_button-base.defaults';
+export interface ArdIconButtonDefaults extends _SimpleButtonDefaults, _FocusableComponentDefaults {
+}
+export declare const ARD_ICON_BUTTON_DEFAULTS: InjectionToken<ArdIconButtonDefaults>;
+export declare function provideIconButtonDefaults(config: Partial<ArdIconButtonDefaults>): Provider;

package/lib/buttons/icon-button/icon-button.module.d.ts

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

package/lib/buttons/icon-button/index.d.ts

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