@ardium-ui/ui 1.0.0

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

@@ -0,0 +1,31 @@
+import { ElementRef, OnChanges, OnDestroy, AfterViewInit, Renderer2 } from '@angular/core';
+import { ComponentColor } from '../types/colors.types';
+import { BadgePosition, BadgeSize } from './badge.types';
+import { FormElementVariant } from '../types/theming.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumBadgeDirective implements OnChanges, AfterViewInit, OnDestroy {
+    private _el;
+    private _renderer;
+    constructor(_el: ElementRef, _renderer: Renderer2);
+    text?: string;
+    color: ComponentColor;
+    variant: FormElementVariant;
+    size: BadgeSize;
+    private _position;
+    get position(): BadgePosition;
+    set position(v: BadgePosition);
+    ariaLabel?: string;
+    private _hidden;
+    get hidden(): boolean;
+    set hidden(v: any);
+    private _overlap;
+    get overlap(): boolean;
+    set overlap(v: any);
+    private _createBadgeElement;
+    private _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; }; "color": { "alias": "ardBadgeColor"; "required": false; }; "variant": { "alias": "ardBadgeVariant"; "required": false; }; "size": { "alias": "ardBadgeSize"; "required": false; }; "position": { "alias": "ardBadgePosition"; "required": false; }; "ariaLabel": { "alias": "ardBadgeAriaLabel"; "required": false; }; "hidden": { "alias": "ardBadgeHidden"; "required": false; }; "overlap": { "alias": "ardBadgeOverlap"; "required": false; }; }, {}, 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/buttons/_button-base.d.ts

@@ -0,0 +1,18 @@
+import { ButtonAppearance } from './general-button.types';
+import { _FocusableComponentBase } from '../_internal/focusable-component';
+import { ComponentColor } from '../types/colors.types';
+import * as i0 from "@angular/core";
+export declare abstract class _ButtonBase extends _FocusableComponentBase {
+    wrapperClasses: string;
+    appearance: ButtonAppearance;
+    color: ComponentColor;
+    private _lightColoring;
+    get lightColoring(): boolean;
+    set lightColoring(v: any);
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    abstract get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ButtonBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_ButtonBase, never, never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "color": { "alias": "color"; "required": false; }; "lightColoring": { "alias": "lightColoring"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,15 @@
+import { SimpleOneAxisAlignment } from '../../types/alignment.types';
+import { _ButtonBase } from '../_button-base';
+import { ButtonVariant } from '../general-button.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumButtonComponent extends _ButtonBase {
+    variant: ButtonVariant;
+    alignIcon: SimpleOneAxisAlignment;
+    private _vertical;
+    get vertical(): boolean;
+    set vertical(v: any);
+    icon?: string;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumButtonComponent, "ard-button", never, { "variant": { "alias": "variant"; "required": false; }; "alignIcon": { "alias": "alignIcon"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { _ButtonBase } from '../_button-base';
+import { FABSize } from '../general-button.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumFabComponent extends _ButtonBase {
+    size: FABSize;
+    private _extended;
+    get extended(): boolean;
+    set extended(v: any);
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumFabComponent, "ard-fab", never, { "size": { "alias": "size"; "required": false; }; "extended": { "alias": "extended"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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/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,13 @@
+import { _FocusableComponentBase } from '../../_internal/focusable-component';
+import { ComponentColor } from '../../types/colors.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumIconButtonComponent extends _FocusableComponentBase {
+    wrapperClasses: string;
+    color: ComponentColor;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumIconButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumIconButtonComponent, "ard-icon-button", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "color": { "alias": "color"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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/calendar/calendar.component.d.ts

@@ -0,0 +1,155 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { ComponentColor } from '../types/colors.types';
+import { _NgModelComponentBase } from '../_internal/ngmodel-component';
+import { CalendarView, CalendarDayContext, CalendarDaysViewHeaderContext, CalendarFloatingMonthContext, CalendarMonthContext, CalendarMonthsViewHeaderContext, CalendarWeekdayContext, CalendarYearContext, CalendarYearsViewHeaderContext } from './calendar.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumCalendarComponent extends _NgModelComponentBase implements OnInit, OnChanges {
+    ngOnInit(): void;
+    private _wasSelectedChecked;
+    ngOnChanges(changes: SimpleChanges): void;
+    todayDate: Date;
+    isDayToday(day: number | null): boolean;
+    isMonthToday(month: number): boolean;
+    isYearToday(year: number): boolean;
+    isDaySelected(day: number | Date | null): boolean;
+    isMonthSelected(month: number | Date): boolean;
+    isYearSelected(year: number | Date): boolean;
+    color: ComponentColor;
+    get ngClasses(): string;
+    private readonly todayYearRangeStart;
+    displayedYearRangeStart: number;
+    private _updateDisplayedYearRangeStart;
+    yearRangeArrayCache: number[] | null;
+    get yearRangeArray(): number[];
+    protected _activeDate: Date;
+    set activeDate(v: Date | string | number);
+    get activeDate(): Date;
+    get activeYear(): number;
+    set activeYear(v: any);
+    get activeMonth(): number;
+    set activeMonth(v: any);
+    protected _selected: Date | null;
+    set selected(v: any);
+    get selected(): Date | null;
+    writeValue(v: any): void;
+    yearSelected: EventEmitter<number>;
+    monthSelected: EventEmitter<number>;
+    selectedChange: EventEmitter<Date | null>;
+    activeYearChange: EventEmitter<number>;
+    activeMonthChange: EventEmitter<number>;
+    viewChange: EventEmitter<CalendarView>;
+    changeEvent: EventEmitter<Date | null>;
+    protected _emitChange(): void;
+    private _highlightedDay;
+    get highlightedDay(): number | null;
+    set highlightedDay(v: number | null);
+    setHighlightedDayAdjustDate(day: number): void;
+    private _highlightedMonth;
+    get highlightedMonth(): number | null;
+    set highlightedMonth(v: number | null);
+    setHighlightedMonthAdjustDate(month: number): void;
+    private _highlightedYear;
+    get highlightedYear(): number | null;
+    set highlightedYear(v: number | null);
+    setHighlightedYearAdjustPage(year: number): void;
+    get currentAriaLabel(): string;
+    onCalendarDayMouseover(day: number | null): void;
+    onCalendarMonthMouseover(month: number): void;
+    onCalendarYearMouseover(year: number): void;
+    private _isUsingKeyboard;
+    onDocumentMousemove(): void;
+    onDocumentKeydown(): void;
+    onCalendarDayClick(day: number | null): void;
+    onCalendarMonthClick(month: number): void;
+    onCalendarYearClick(year: number): void;
+    onDayGridFocus(): void;
+    onDayGridBlur(): void;
+    onDayGridClick(): void;
+    onMonthGridFocus(): void;
+    onMonthGridBlur(): void;
+    onMonthGridClick(): void;
+    onYearGridFocus(): void;
+    onYearGridBlur(): void;
+    onYearGridClick(): void;
+    onMainGridKeydown(event: KeyboardEvent): void;
+    private _onEnterPress;
+    private _onArrowUpPress;
+    private _onArrowDownPress;
+    private _onArrowLeftPress;
+    private _onArrowRightPress;
+    private _onHomePress;
+    private _onEndPress;
+    private _onPageUpPress;
+    private _onPageDownPress;
+    selectDay(day: number | Date | null): void;
+    selectMonth(month: number | Date | null): void;
+    selectYear(year: number | Date | null): void;
+    selectCurrentlyHighlighted(): void;
+    changeMonth(offset: number): void;
+    changeYear(offset: number): void;
+    changeYearsViewPage(pages: number): void;
+    highlightNextDay(offset?: number): void;
+    highlightPreviousDay(offset?: number): void;
+    highlightNextMonth(offset?: number): void;
+    highlightPreviousMonth(offset?: number): void;
+    highlightNextYear(offset?: number): void;
+    highlightPreviousYear(offset?: number): void;
+    highlightFirstDay(): void;
+    highlightLastDay(): void;
+    highlightFirstMonth(): void;
+    highlightLastMonth(): void;
+    highlightFirstYear(): void;
+    highlightLastYear(): void;
+    highlightSameDayNextMonth(): void;
+    highlightSameDayPreviousMonth(): void;
+    private _fixDateAfterMonthChange;
+    highlightSameDayNextYear(): void;
+    highlightSameDayPreviousYear(): void;
+    private _fixDateAfterYearChange;
+    highlightSameMonthNextYear(multiple: boolean): void;
+    highlightSameMonthPreviousYear(multiple: boolean): void;
+    highlightSameYearNextPage(multiple: boolean): void;
+    highlightSameYearPreviousPage(multiple: boolean): void;
+    protected _firstWeekday: number;
+    get firstWeekday(): number;
+    set firstWeekday(v: any);
+    protected _nointeract: boolean;
+    get nointeract(): boolean;
+    set nointeract(v: any);
+    protected _staticHeight: boolean;
+    get staticHeight(): boolean;
+    set staticHeight(v: any);
+    calendarArray: (number | null)[][];
+    reserveTopRow: boolean;
+    protected _updateCalendarArray(): void;
+    readonly monthsArray: number[];
+    private _yearsArrayCache;
+    private _yearsArrayCacheStartYear;
+    getYearsArray(): number[];
+    weekdayArray: number[];
+    protected _updateWeekdayArray(): void;
+    activeView: CalendarView;
+    set startView(v: CalendarView);
+    openYearsView(): void;
+    openMonthsView(): void;
+    openDaysView(): void;
+    yearsViewHeaderTemplate?: TemplateRef<CalendarYearsViewHeaderContext>;
+    monthsViewHeaderTemplate?: TemplateRef<CalendarMonthsViewHeaderContext>;
+    daysViewHeaderTemplate?: TemplateRef<CalendarDaysViewHeaderContext>;
+    weekdayTemplate?: TemplateRef<CalendarWeekdayContext>;
+    floatingMonthTemplate?: TemplateRef<CalendarFloatingMonthContext>;
+    yearTemplate?: TemplateRef<CalendarYearContext>;
+    monthTemplate?: TemplateRef<CalendarMonthContext>;
+    dayTemplate?: TemplateRef<CalendarDayContext>;
+    getYearsViewHeaderContext(): CalendarYearsViewHeaderContext;
+    getMonthsViewHeaderContext(): CalendarMonthsViewHeaderContext;
+    getDaysViewHeaderContext(): CalendarDaysViewHeaderContext;
+    getWeekdayContext(dayIndex: number): CalendarWeekdayContext;
+    getFloatingMonthContext(): CalendarFloatingMonthContext;
+    getYearContext(year: number): CalendarYearContext;
+    getMonthContext(month: number): CalendarMonthContext;
+    getDayContext(day: number): CalendarDayContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumCalendarComponent, "ard-calendar", never, { "color": { "alias": "color"; "required": false; }; "activeYear": { "alias": "activeYear"; "required": false; }; "activeMonth": { "alias": "activeMonth"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "firstWeekday": { "alias": "firstWeekday"; "required": false; }; "nointeract": { "alias": "nointeract"; "required": false; }; "staticHeight": { "alias": "staticHeight"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; }, { "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "selectedChange": "selectedChange"; "activeYearChange": "activeYearChange"; "activeMonthChange": "activeMonthChange"; "viewChange": "viewChange"; "changeEvent": "change"; }, ["yearsViewHeaderTemplate", "monthsViewHeaderTemplate", "daysViewHeaderTemplate", "weekdayTemplate", "floatingMonthTemplate", "yearTemplate", "monthTemplate", "dayTemplate"], never, false, never>;
+}

package/lib/calendar/calendar.directives.d.ts

@@ -0,0 +1,51 @@
+import { TemplateRef } from '@angular/core';
+import { CalendarDayContext, CalendarFloatingMonthContext, CalendarDaysViewHeaderContext, CalendarMonthContext, CalendarWeekdayContext, CalendarYearContext, CalendarMonthsViewHeaderContext, CalendarYearsViewHeaderContext } from './calendar.types';
+import * as i0 from "@angular/core";
+export declare class ArdDaysViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarDaysViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarDaysViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDaysViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDaysViewHeaderTemplateDirective, "ard-calendar > ng-template[ard-header-tmp], ard-datepicker > ng-template[ard-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdYearsViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarYearsViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarYearsViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdYearsViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdYearsViewHeaderTemplateDirective, "ard-calendar > ng-template[ard-year-picker-header-tmp], ard-datepicker > ng-template[ard-year-picker-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdMonthsViewHeaderTemplateDirective {
+    template: TemplateRef<CalendarMonthsViewHeaderContext>;
+    constructor(template: TemplateRef<CalendarMonthsViewHeaderContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdMonthsViewHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdMonthsViewHeaderTemplateDirective, "ard-calendar > ng-template[ard-month-picker-header-tmp], ard-datepicker > ng-template[ard-month-picker-header-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdWeekdayTemplateDirective {
+    template: TemplateRef<CalendarWeekdayContext>;
+    constructor(template: TemplateRef<CalendarWeekdayContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdWeekdayTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdWeekdayTemplateDirective, "ard-calendar > ng-template[ard-weekday-tmp], ard-datepicker > ng-template[ard-weekday-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdFloatingMonthTemplateDirective {
+    template: TemplateRef<CalendarFloatingMonthContext>;
+    constructor(template: TemplateRef<CalendarFloatingMonthContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdFloatingMonthTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdFloatingMonthTemplateDirective, "ard-calendar > ng-template[ard-floating-month-tmp], ard-datepicker > ng-template[ard-floating-month-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdYearTemplateDirective {
+    template: TemplateRef<CalendarYearContext>;
+    constructor(template: TemplateRef<CalendarYearContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdYearTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdYearTemplateDirective, "ard-calendar > ng-template[ard-year-tmp], ard-datepicker > ng-template[ard-year-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdMonthTemplateDirective {
+    template: TemplateRef<CalendarMonthContext>;
+    constructor(template: TemplateRef<CalendarMonthContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdMonthTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdMonthTemplateDirective, "ard-calendar > ng-template[ard-month-tmp], ard-datepicker > ng-template[ard-month-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdDayTemplateDirective {
+    template: TemplateRef<CalendarDayContext>;
+    constructor(template: TemplateRef<CalendarDayContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDayTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDayTemplateDirective, "ard-calendar > ng-template[ard-day-tmp], ard-datepicker > ng-template[ard-day-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/calendar/calendar.helpers.d.ts

@@ -0,0 +1,15 @@
+export type CalendarArray = {
+    array: (number | null)[][];
+    leadingSpaces: number;
+    trailingSpaces: number;
+    weeks: number;
+};
+/**
+ * Generates a layout array to be used to create a calendar page for the given date's month.
+ *
+ * The returned object contains an array to create the layout from, the number of leading and trailing spaces in the layout, and the number of weeks (full or not) in the month.
+ * @param date The date to get the month from.
+ * @param firstWeekday The index of the first weekday in the calendar layout. Starts at Sunday, with the index 0. Defaults to 1.
+ * @returns A {@link CalendarArray} object.
+ */
+export declare function getMonthLayout(date: Date, firstWeekday?: number): CalendarArray;

package/lib/calendar/calendar.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./calendar.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../buttons/button/button.module";
+import * as i4 from "../buttons/icon-button/icon-button.module";
+import * as i5 from "../icon/icon.module";
+export declare class ArdiumCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumCalendarModule, [typeof i1.ArdiumCalendarComponent], [typeof i2.CommonModule, typeof i3.ArdiumButtonModule, typeof i4.ArdiumIconButtonModule, typeof i5.ArdiumIconModule], [typeof i1.ArdiumCalendarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumCalendarModule>;
+}

package/lib/calendar/calendar.types.d.ts

@@ -0,0 +1,80 @@
+export declare const CalendarRangeVariant: {
+    readonly Row: "row";
+    readonly OutlineRounded: "outline-rounded";
+    readonly OutlineSharp: "outline-sharp";
+};
+export type CalendarRangeVariant = (typeof CalendarRangeVariant)[keyof typeof CalendarRangeVariant];
+export type DateRange = {
+    low: Date;
+    high: Date;
+};
+export type YearRange = {
+    low: number;
+    high: number;
+};
+export declare const CalendarView: {
+    readonly Years: "years";
+    readonly Months: "months";
+    readonly Days: "days";
+};
+export type CalendarView = (typeof CalendarView)[keyof typeof CalendarView];
+export type CalendarYearsViewHeaderContext = {
+    nextPage: () => void;
+    prevPage: () => void;
+    openDaysView: () => void;
+    yearRange: YearRange;
+    dateRange: DateRange;
+    $implicit: DateRange;
+};
+export type CalendarMonthsViewHeaderContext = {
+    openDaysView: () => void;
+    openYearsView: () => void;
+    year: number;
+    date: Date;
+    $implicit: number;
+};
+export type CalendarDaysViewHeaderContext = {
+    nextMonth: () => void;
+    prevMonth: () => void;
+    nextYear: () => void;
+    prevYear: () => void;
+    openYearsView: () => void;
+    openMonthsView: () => void;
+    year: number;
+    month: number;
+    date: Date;
+    $implicit: Date;
+};
+export type CalendarWeekdayContext = {
+    dayIndex: number;
+    date: Date;
+    $implicit: Date;
+};
+export type CalendarFloatingMonthContext = {
+    month: number;
+    date: Date;
+    $implicit: Date;
+};
+export type CalendarYearContext = {
+    value: number;
+    date: Date;
+    $implicit: number;
+    select: (year: number) => void;
+};
+export type CalendarMonthContext = {
+    month: number;
+    date: Date;
+    $implicit: Date;
+    select: (month: number | Date) => void;
+};
+export type CalendarDayContext = {
+    value: number;
+    date: Date;
+    $implicit: number;
+    select: (day: number | Date) => void;
+};
+export type CalendarActionButtonsContext = {
+    cancel: () => void;
+    apply: () => void;
+    reset: () => void;
+};

package/lib/card/card.children.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { OneAxisAlignment } from '../types/alignment.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumCardHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumCardHeaderComponent, "ard-card-header", never, {}, {}, never, ["[ard-card-avatar]", "ard-card-title, ard-card-subtitle,\n      [ard-card-title], [ard-card-subtitle]", "*"], false, never>;
+}
+export declare class ArdiumCardSubtitleDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardSubtitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardSubtitleDirective, "ard-card-subtitle, [ard-card-subtitle]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumCardTitleDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardTitleDirective, "ard-card-title, [ard-card-title]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumCardAvatarDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardAvatarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardAvatarDirective, "[ard-card-avatar]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumCardContentDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardContentDirective, "ard-card-content, [ard-card-content]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumCardImageDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardImageDirective, "[ard-card-image]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumCardActionButtonsDirective {
+    align: OneAxisAlignment;
+    get alignClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardActionButtonsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardActionButtonsDirective, "ard-card-action-buttons, [ard-card-action-buttons]", never, { "align": { "alias": "align"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class ArdiumCardFooterDirective {
+    constructor(renderer: Renderer2, hostElement: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardFooterDirective, "ard-card-footer, [ard-card-footer]", never, {}, {}, never, never, false, never>;
+}

package/lib/card/card.component.d.ts

@@ -0,0 +1,13 @@
+import { CardAppearance, CardVariant } from './card.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumCardDirective {
+    appearance: CardAppearance;
+    variant: CardVariant;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumCardDirective, "[ard-card]", never, { "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class ArdiumCardComponent extends ArdiumCardDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumCardComponent, "ard-card", never, {}, {}, never, ["*"], false, never>;
+}

package/lib/card/card.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./card.component";
+import * as i2 from "./card.children";
+import * as i3 from "@angular/common";
+export declare class ArdiumCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumCardModule, [typeof i1.ArdiumCardComponent, typeof i1.ArdiumCardDirective, typeof i2.ArdiumCardHeaderComponent, typeof i2.ArdiumCardTitleDirective, typeof i2.ArdiumCardSubtitleDirective, typeof i2.ArdiumCardAvatarDirective, typeof i2.ArdiumCardContentDirective, typeof i2.ArdiumCardImageDirective, typeof i2.ArdiumCardActionButtonsDirective, typeof i2.ArdiumCardFooterDirective], [typeof i3.CommonModule], [typeof i1.ArdiumCardComponent, typeof i1.ArdiumCardDirective, typeof i2.ArdiumCardHeaderComponent, typeof i2.ArdiumCardTitleDirective, typeof i2.ArdiumCardSubtitleDirective, typeof i2.ArdiumCardAvatarDirective, typeof i2.ArdiumCardContentDirective, typeof i2.ArdiumCardImageDirective, typeof i2.ArdiumCardActionButtonsDirective, typeof i2.ArdiumCardFooterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumCardModule>;
+}

package/lib/card/card.types.d.ts

@@ -0,0 +1,10 @@
+export declare const CardAppearance: {
+    readonly Outlined: "outlined";
+    readonly Raised: "raised";
+};
+export type CardAppearance = (typeof CardAppearance)[keyof typeof CardAppearance];
+export declare const CardVariant: {
+    readonly Rounded: "rounded";
+    readonly Sharp: "sharp";
+};
+export type CardVariant = (typeof CardVariant)[keyof typeof CardVariant];

package/lib/checkbox/checkbox.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { SimpleComponentColor } from '../types/colors.types';
+import { _BooleanComponentBase } from './../_internal/boolean-component';
+import { CheckboxState } from './checkbox.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumCheckboxComponent extends _BooleanComponentBase implements ControlValueAccessor {
+    wrapperClasses: string;
+    htmlId?: string;
+    color: SimpleComponentColor;
+    unselectedColor: SimpleComponentColor;
+    get ngClasses(): string;
+    set selected(v: any);
+    get selected(): boolean;
+    state: CheckboxState;
+    stateChange: EventEmitter<CheckboxState>;
+    toggleState(): void;
+    protected _emitChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumCheckboxComponent, "ard-checkbox", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "htmlId": { "alias": "htmlId"; "required": false; }; "color": { "alias": "color"; "required": false; }; "unselectedColor": { "alias": "unselectedColor"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "stateChange": "stateChange"; }, never, never, false, never>;
+}

package/lib/checkbox/checkbox.module.d.ts

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