@ardium-ui/ui 1.0.0

package/lib/checkbox/checkbox.types.d.ts

@@ -0,0 +1,6 @@
+export declare const CheckboxState: {
+    readonly Unselected: "unselected";
+    readonly Indeterminate: "indeterminate";
+    readonly Selected: "selected";
+};
+export type CheckboxState = (typeof CheckboxState)[keyof typeof CheckboxState];

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

@@ -0,0 +1,50 @@
+import { AfterViewInit, EventEmitter } from '@angular/core';
+import { SimpleItemStorageHost } from '../_internal/item-storages/simple-item-storage';
+import { _NgModelComponentBase } from '../_internal/ngmodel-component';
+import { ComponentColor } from '../types/colors.types';
+import { ArdOptionSimple, CompareWithFn } from '../types/item-storage.types';
+import { CheckboxListAlignType } from './checkbox-list.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumCheckboxListComponent extends _NgModelComponentBase implements SimpleItemStorageHost, AfterViewInit {
+    htmlId: string;
+    readonly DEFAULTS: {
+        valueFrom: string;
+        labelFrom: string;
+        disabledFrom: string;
+    };
+    readonly multiselectable = true;
+    readonly requireValue = false;
+    private _itemStorage;
+    set items(v: any[]);
+    get items(): ArdOptionSimple[];
+    compareWith?: CompareWithFn;
+    private _invertDisabled;
+    get invertDisabled(): boolean;
+    set invertDisabled(v: any);
+    private _maxSelectedItems?;
+    get maxSelectedItems(): number | undefined;
+    set maxSelectedItems(v: any);
+    color: ComponentColor;
+    align: CheckboxListAlignType;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    get ngClasses(): string;
+    get value(): any;
+    set value(v: any);
+    valueChange: EventEmitter<any>;
+    changeEvent: EventEmitter<any>;
+    private _valueBeforeInit;
+    writeValue(v: any): void;
+    private _isViewInit;
+    ngAfterViewInit(): void;
+    protected _emitChange(): void;
+    onItemHighlight(v: ArdOptionSimple): void;
+    onItemFocus(v: ArdOptionSimple): void;
+    onItemBlur(): void;
+    selectItem(v: ArdOptionSimple): void;
+    unselectItem(v: ArdOptionSimple): void;
+    toggleItem(v: ArdOptionSimple): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumCheckboxListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumCheckboxListComponent, "ard-checkbox-list", never, { "htmlId": { "alias": "htmlId"; "required": false; }; "items": { "alias": "items"; "required": false; }; "invertDisabled": { "alias": "invertDisabled"; "required": false; }; "maxSelectedItems": { "alias": "maxSelectedItems"; "required": false; }; "color": { "alias": "color"; "required": false; }; "align": { "alias": "align"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "changeEvent": "change"; }, never, never, false, never>;
+}

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

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

package/lib/checkbox-list/checkbox-list.types.d.ts

@@ -0,0 +1,7 @@
+export declare const CheckboxListAlignType: {
+    readonly LeftClumped: "left-clumped";
+    readonly LeftSplit: "left-split";
+    readonly RightSplit: "right-split";
+    readonly RightClumped: "right-clumped";
+};
+export type CheckboxListAlignType = (typeof CheckboxListAlignType)[keyof typeof CheckboxListAlignType];

package/lib/chip/chip.component.d.ts

@@ -0,0 +1,18 @@
+import { SimpleOneAxisAlignment } from '../types/alignment.types';
+import { ComponentColor } from '../types/colors.types';
+import { DecorationElementAppearance, FormElementVariant } from '../types/theming.types';
+import { _DisablableComponentBase } from './../_internal/disablable-component';
+import * as i0 from "@angular/core";
+export declare class ArdiumChipComponent extends _DisablableComponentBase {
+    contentAlignment: SimpleOneAxisAlignment;
+    appearance: DecorationElementAppearance;
+    variant: FormElementVariant;
+    color: ComponentColor;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    wrapperClasses: string;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumChipComponent, "ard-chip", never, { "contentAlignment": { "alias": "contentAlignment"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/chip/chip.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./chip.component";
+import * as i2 from "./selectable-chip/selectable-chip.component";
+import * as i3 from "./deletable-chip/deletable-chip.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../_internal/clear-button/clear-button.module";
+export declare class ArdiumChipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumChipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumChipModule, [typeof i1.ArdiumChipComponent, typeof i2.ArdiumSelectableChipComponent, typeof i3.ArdiumDeletableChipComponent], [typeof i4.CommonModule, typeof i5._ClearButtonModule], [typeof i1.ArdiumChipComponent, typeof i2.ArdiumSelectableChipComponent, typeof i3.ArdiumDeletableChipComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumChipModule>;
+}

package/lib/chip/deletable-chip/deletable-chip.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { SimpleOneAxisAlignment } from '../../types/alignment.types';
+import { ComponentColor } from '../../types/colors.types';
+import { DecorationElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { _FocusableComponentBase } from '../../_internal/focusable-component';
+import * as i0 from "@angular/core";
+export declare class ArdiumDeletableChipComponent extends _FocusableComponentBase {
+    readonly DEFAULTS: {
+        deleteButtonTitle: string;
+    };
+    deleteButtonTitle: string;
+    contentAlignment: SimpleOneAxisAlignment;
+    appearance: DecorationElementAppearance;
+    variant: FormElementVariant;
+    color: ComponentColor;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    wrapperClasses: string;
+    get ngClasses(): string;
+    deleteEvent: EventEmitter<MouseEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDeletableChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumDeletableChipComponent, "ard-deletable-chip", never, { "deleteButtonTitle": { "alias": "deleteButtonTitle"; "required": false; }; "contentAlignment": { "alias": "contentAlignment"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; }, { "deleteEvent": "delete"; }, never, ["*"], false, never>;
+}

package/lib/chip/selectable-chip/selectable-chip.component.d.ts

@@ -0,0 +1,24 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { SimpleOneAxisAlignment } from '../../types/alignment.types';
+import { ComponentColor } from '../../types/colors.types';
+import { DecorationElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { _BooleanComponentBase } from './../../_internal/boolean-component';
+import * as i0 from "@angular/core";
+export declare class ArdiumSelectableChipComponent extends _BooleanComponentBase implements ControlValueAccessor {
+    readonly DEFAULTS: {
+        chipTitle: string;
+    };
+    chipTitle: string;
+    useSelectionIcon: boolean;
+    contentAlignment: SimpleOneAxisAlignment;
+    appearance: DecorationElementAppearance;
+    variant: FormElementVariant;
+    color: ComponentColor;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    wrapperClasses: string;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSelectableChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumSelectableChipComponent, "ard-selectable-chip", never, { "chipTitle": { "alias": "chipTitle"; "required": false; }; "useSelectionIcon": { "alias": "useSelectionIcon"; "required": false; }; "contentAlignment": { "alias": "contentAlignment"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/color/color-display/color-display.component.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit } from '@angular/core';
+import { ColorDisplayAppearance } from './color-display.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumColorDisplayComponent implements AfterViewInit {
+    ariaLabel?: string;
+    private _withLabel;
+    get withLabel(): boolean;
+    set withLabel(v: any);
+    appearance: ColorDisplayAppearance;
+    get ngClasses(): string;
+    private _color?;
+    get color(): string | null;
+    set color(v: any);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumColorDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumColorDisplayComponent, "ard-color-display", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "withLabel": { "alias": "withLabel"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/color/color-display/color-display.module.d.ts

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

package/lib/color/color-display/color-display.types.d.ts

@@ -0,0 +1,9 @@
+export declare const ColorDisplayAppearance: {
+    readonly Rounded: "rounded with-border";
+    readonly Circle: "circle with-border";
+    readonly Sharp: "sharp with-border";
+    readonly RoundedBorderless: "rounded";
+    readonly CircleBorderless: "circle";
+    readonly SharpBorderless: "sharp";
+};
+export type ColorDisplayAppearance = (typeof ColorDisplayAppearance)[keyof typeof ColorDisplayAppearance];

package/lib/color/color-picker/color-picker.component.d.ts

@@ -0,0 +1,125 @@
+import { ElementRef, EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import * as Color from 'color';
+import { _NgModelComponentBase } from '../../_internal/ngmodel-component';
+import { ColorPickerColorReferenceContext, ColorPickerIndicatorContext, ColorPickerVariant, _ColorPickerInputsSectionType } from './color-picker.types';
+import * as i0 from "@angular/core";
+type TripleInputObject = {
+    value: number;
+    max: number;
+};
+export declare class ArdiumColorPickerComponent extends _NgModelComponentBase implements OnInit {
+    private _withOpacity;
+    get withOpacity(): boolean;
+    set withOpacity(v: any);
+    private _referenceColor;
+    private _wasReferenceColorSet;
+    set referenceColor(v: any);
+    get referenceColor(): Color;
+    wrapperClasses: string;
+    variant: ColorPickerVariant;
+    private _vertical;
+    get vertical(): boolean;
+    set vertical(v: any);
+    get ngClasses(): string;
+    private _value;
+    private _exactHue;
+    set value(v: any);
+    get value(): Color;
+    set colorHue(v: any);
+    get colorHue(): number;
+    set colorSaturation(v: any);
+    get colorSaturation(): number;
+    set colorValue(v: any);
+    get colorValue(): number;
+    set colorOpacity(v: any);
+    get colorOpacity(): number;
+    valueChange: EventEmitter<Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | Color<string | number | ArrayLike<number> | any | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }> | {
+        [key: string]: any;
+    }>>;
+    colorHueChange: EventEmitter<number>;
+    colorSaturationChange: EventEmitter<number>;
+    colorValueChange: EventEmitter<number>;
+    colorOpacityChange: EventEmitter<number>;
+    writeValue(v: any): void;
+    ngOnInit(): void;
+    shadeMapEl: ElementRef<HTMLDivElement>;
+    hueMapEl: ElementRef<HTMLDivElement>;
+    opacityMapEl: ElementRef<HTMLDivElement>;
+    focusedArea: 'shade' | 'hue' | 'opacity' | null;
+    onShadeAreaMouseDown(event: MouseEvent): void;
+    onHueAreaMouseDown(event: MouseEvent): void;
+    onOpacityAreaMouseDown(event: MouseEvent): void;
+    private _isMouseDown;
+    onDocumentMouseUp(): void;
+    onDocumentMousemove(event: MouseEvent | TouchEvent): void;
+    private _updateShadeFromEvent;
+    private _updateHueFromEvent;
+    private _updateOpacityFromEvent;
+    currentShadeMapColor: Color;
+    private _updateCurrentShadeMapColor;
+    currentOpacityMapColor: Color;
+    private _updateCurrentOpacityMapColor;
+    getShadeIndicatorPosition(): {
+        '--top': string;
+        '--left': string;
+    };
+    getHueIndicatorPosition(): {
+        '--top': string;
+    };
+    getOpacityIndicatorPosition(): {
+        '--top': string;
+    };
+    inputTypes: _ColorPickerInputsSectionType[];
+    currentInputType: _ColorPickerInputsSectionType;
+    onCurrentInputTypeChange(value: _ColorPickerInputsSectionType[]): void;
+    hexInputValue: string;
+    private _updateHexInputValue;
+    tripleInputData1: TripleInputObject;
+    tripleInputData2: TripleInputObject;
+    tripleInputData3: TripleInputObject;
+    tripleInputData4: TripleInputObject;
+    private _updateTripleInputValues;
+    onHexInputChange(value: string): void;
+    onTripleInputChange(value: number | null, index: number): void;
+    protected _emitChange(): void;
+    shadeIndicatorTemplate?: TemplateRef<any>;
+    hueIndicatorTemplate?: TemplateRef<any>;
+    opacityIndicatorTemplate?: TemplateRef<any>;
+    colorReferenceTemplate?: TemplateRef<any>;
+    shadeIndicatorTemplateChild?: TemplateRef<any>;
+    hueIndicatorTemplateChild?: TemplateRef<any>;
+    opacityIndicatorTemplateChild?: TemplateRef<any>;
+    colorReferenceTemplateChild?: TemplateRef<any>;
+    getIndicatorContext(): ColorPickerIndicatorContext;
+    getColorReferenceContext(): ColorPickerColorReferenceContext;
+    onKeydown(event: KeyboardEvent): void;
+    nudgeColorSaturation(direction: 1 | -1, hasShift?: boolean): void;
+    nudgeColorValue(direction: 1 | -1, hasShift?: boolean): void;
+    nudgeColorHue(direction: 1 | -1, hasShift?: boolean): void;
+    nudgeColorOpacity(direction: 1 | -1, hasShift?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumColorPickerComponent, "ard-color-picker", never, { "withOpacity": { "alias": "withOpacity"; "required": false; }; "referenceColor": { "alias": "referenceColor"; "required": false; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "value": { "alias": "value"; "required": false; }; "colorHue": { "alias": "colorHue"; "required": false; }; "colorSaturation": { "alias": "colorSaturation"; "required": false; }; "colorValue": { "alias": "colorValue"; "required": false; }; "colorOpacity": { "alias": "colorOpacity"; "required": false; }; "shadeIndicatorTemplate": { "alias": "shadeIndicatorTemplate"; "required": false; }; "hueIndicatorTemplate": { "alias": "hueIndicatorTemplate"; "required": false; }; "opacityIndicatorTemplate": { "alias": "opacityIndicatorTemplate"; "required": false; }; "colorReferenceTemplate": { "alias": "colorReferenceTemplate"; "required": false; }; }, { "valueChange": "valueChange"; "colorHueChange": "colorHueChange"; "colorSaturationChange": "colorSaturationChange"; "colorValueChange": "colorValueChange"; "colorOpacityChange": "colorOpacityChange"; }, ["shadeIndicatorTemplateChild", "hueIndicatorTemplateChild", "opacityIndicatorTemplateChild", "colorReferenceTemplateChild"], never, false, never>;
+}
+export {};

package/lib/color/color-picker/color-picker.directives.d.ts

@@ -0,0 +1,27 @@
+import { TemplateRef } from '@angular/core';
+import { ColorPickerColorReferenceContext, ColorPickerIndicatorContext } from './color-picker.types';
+import * as i0 from "@angular/core";
+export declare class ArdColorPickerShadeIndicatorTemplateDirective {
+    template: TemplateRef<ColorPickerIndicatorContext>;
+    constructor(template: TemplateRef<ColorPickerIndicatorContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdColorPickerShadeIndicatorTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdColorPickerShadeIndicatorTemplateDirective, "ard-color-picker > ng-template[ard-shade-indicator-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdColorPickerHueIndicatorTemplateDirective {
+    template: TemplateRef<ColorPickerIndicatorContext>;
+    constructor(template: TemplateRef<ColorPickerIndicatorContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdColorPickerHueIndicatorTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdColorPickerHueIndicatorTemplateDirective, "ard-color-picker > ng-template[ard-hue-indicator-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdColorPickerOpacityIndicatorTemplateDirective {
+    template: TemplateRef<ColorPickerIndicatorContext>;
+    constructor(template: TemplateRef<ColorPickerIndicatorContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdColorPickerOpacityIndicatorTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdColorPickerOpacityIndicatorTemplateDirective, "ard-color-picker > ng-template[ard-opacity-indicator-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdColorPickerColorReferenceTemplateDirective {
+    template: TemplateRef<ColorPickerColorReferenceContext>;
+    constructor(template: TemplateRef<ColorPickerColorReferenceContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdColorPickerColorReferenceTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdColorPickerColorReferenceTemplateDirective, "ard-color-picker > ng-template[ard-color-reference-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/color/color-picker/color-picker.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./color-picker.component";
+import * as i2 from "./color-picker.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../../select/select.module";
+import * as i5 from "../../option/option.module";
+import * as i6 from "../../inputs/number-input/number-input.module";
+import * as i7 from "../../inputs/hex-input/hex-input.module";
+export declare class ArdiumColorPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumColorPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumColorPickerModule, [typeof i1.ArdiumColorPickerComponent, typeof i2.ArdColorPickerHueIndicatorTemplateDirective, typeof i2.ArdColorPickerShadeIndicatorTemplateDirective, typeof i2.ArdColorPickerColorReferenceTemplateDirective, typeof i2.ArdColorPickerOpacityIndicatorTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumSelectModule, typeof i5.ArdiumOptionModule, typeof i6.ArdiumNumberInputModule, typeof i7.ArdiumHexInputModule], [typeof i1.ArdiumColorPickerComponent, typeof i2.ArdColorPickerHueIndicatorTemplateDirective, typeof i2.ArdColorPickerShadeIndicatorTemplateDirective, typeof i2.ArdColorPickerColorReferenceTemplateDirective, typeof i2.ArdColorPickerOpacityIndicatorTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumColorPickerModule>;
+}

package/lib/color/color-picker/color-picker.types.d.ts

@@ -0,0 +1,21 @@
+import * as Color from 'color';
+export type ColorPickerIndicatorContext = {
+    $implicit: Color;
+};
+export type ColorPickerColorReferenceContext = {
+    color: Color;
+    $implicit: Color;
+    referenceColor: Color;
+};
+export declare const _ColorPickerInputsSectionType: {
+    readonly HEX: "HEX";
+    readonly RGB: "RGB";
+    readonly HSL: "HSL";
+    readonly HSV: "HSV";
+};
+export type _ColorPickerInputsSectionType = (typeof _ColorPickerInputsSectionType)[keyof typeof _ColorPickerInputsSectionType];
+export declare const ColorPickerVariant: {
+    readonly Rounded: "rounded";
+    readonly Sharp: "sharp";
+};
+export type ColorPickerVariant = (typeof ColorPickerVariant)[keyof typeof ColorPickerVariant];

package/lib/dialog/dialog.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { ComponentColor } from '../types/colors.types';
+import { PanelAppearance, PanelVariant } from '../types/theming.types';
+import { DialogButtonsContext, DialogResult } from './dialog.types';
+import { ButtonAppearance } from '../buttons/general-button.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumDialogComponent {
+    appearance: PanelAppearance;
+    variant: PanelVariant;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    heading?: string;
+    readonly noCloseButton: import("@angular/core").WritableSignal<boolean>;
+    set _noCloseButton(v: any);
+    readonly noBackdrop: import("@angular/core").WritableSignal<boolean>;
+    set _noBackdrop(v: any);
+    readonly disableBackdropClose: import("@angular/core").WritableSignal<boolean>;
+    set _disableBackdropClose(v: any);
+    private _open;
+    get open(): boolean;
+    set open(v: any);
+    openChange: EventEmitter<boolean>;
+    closeEvent: EventEmitter<DialogResult>;
+    confirmEvent: EventEmitter<null>;
+    rejectEvent: EventEmitter<null>;
+    confirmButtonText: string;
+    confirmButtonColor: ComponentColor;
+    confirmButtonAppearance: ButtonAppearance;
+    rejectButtonText: string;
+    rejectButtonColor: ComponentColor;
+    rejectButtonAppearance: ButtonAppearance;
+    readonly noRejectButton: import("@angular/core").WritableSignal<boolean>;
+    set _noRejectButton(v: any);
+    readonly canConfirm: import("@angular/core").WritableSignal<boolean>;
+    set _canConfirm(v: any);
+    onConfirmClick(): void;
+    onRejectClick(): void;
+    onModalClose(): void;
+    buttonsTemplate?: TemplateRef<DialogButtonsContext>;
+    getButtonsContext(): DialogButtonsContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumDialogComponent, "ard-dialog", never, { "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; "_noCloseButton": { "alias": "noCloseButton"; "required": false; }; "_noBackdrop": { "alias": "noBackdrop"; "required": false; }; "_disableBackdropClose": { "alias": "disableBackdropClose"; "required": false; }; "open": { "alias": "open"; "required": false; }; "confirmButtonText": { "alias": "confirmButtonText"; "required": false; }; "confirmButtonColor": { "alias": "confirmButtonColor"; "required": false; }; "confirmButtonAppearance": { "alias": "confirmButtonAppearance"; "required": false; }; "rejectButtonText": { "alias": "rejectButtonText"; "required": false; }; "rejectButtonColor": { "alias": "rejectButtonColor"; "required": false; }; "rejectButtonAppearance": { "alias": "rejectButtonAppearance"; "required": false; }; "_noRejectButton": { "alias": "noRejectButton"; "required": false; }; "_canConfirm": { "alias": "canConfirm"; "required": false; }; }, { "openChange": "openChange"; "closeEvent": "close"; "confirmEvent": "confirm"; "rejectEvent": "reject"; }, ["buttonsTemplate"], ["*"], false, never>;
+}

package/lib/dialog/dialog.directives.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import { DialogButtonsContext } from './dialog.types';
+import * as i0 from "@angular/core";
+export declare class ArdDialogButtonsTemplateDirective {
+    template: TemplateRef<DialogButtonsContext>;
+    constructor(template: TemplateRef<DialogButtonsContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdDialogButtonsTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdDialogButtonsTemplateDirective, "ard-dialog > ng-template[ard-buttons-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/dialog/dialog.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog.component";
+import * as i2 from "./dialog.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../buttons/button/button.module";
+import * as i5 from "../modal/modal.module";
+export declare class ArdiumDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumDialogModule, [typeof i1.ArdiumDialogComponent, typeof i2.ArdDialogButtonsTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumButtonModule, typeof i5.ArdiumModalModule], [typeof i1.ArdiumDialogComponent, typeof i2.ArdDialogButtonsTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumDialogModule>;
+}

package/lib/dialog/dialog.types.d.ts

@@ -0,0 +1,28 @@
+import { ButtonAppearance } from '../buttons/general-button.types';
+import { ComponentColor } from '../types/colors.types';
+import { PanelAppearance, PanelVariant } from '../types/theming.types';
+export declare const DialogResult: {
+    readonly Confirm: "confirm";
+    readonly Reject: "reject";
+    readonly Close: "close";
+};
+export type DialogResult = (typeof DialogResult)[keyof typeof DialogResult];
+export type DialogButtonsContext = {
+    confirmButton: {
+        text: string;
+        color: ComponentColor;
+        appearance: ButtonAppearance;
+    };
+    rejectButton: {
+        enabled: boolean;
+        text: string;
+        color: ComponentColor;
+        appearance: ButtonAppearance;
+    };
+    canConfirm: boolean;
+    onConfirm: () => void;
+    onReject: () => void;
+    dialogAppearance: PanelAppearance;
+    dialogVariant: PanelVariant;
+    dialogCompact: boolean;
+};

package/lib/divider/divider.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class ArdiumDividerComponent {
+    private _vertical;
+    get vertical(): boolean;
+    set vertical(v: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumDividerComponent, "ard-divider", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/divider/divider.module.d.ts

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

package/lib/dropdown-panel/dropdown-panel.component.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewChecked, AfterViewInit, EventEmitter, TemplateRef } from '@angular/core';
+import { DropdownPanelAppearance, DropdownPanelVariant, ScrollAlignment } from './dropdown-panel.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumDropdownPanelComponent implements AfterViewInit, AfterViewChecked {
+    constructor();
+    private _scrollRef;
+    private _scrollElement;
+    panelId: string;
+    headerTemplate?: TemplateRef<any>;
+    footerTemplate?: TemplateRef<any>;
+    filterValue?: string;
+    appearance: DropdownPanelAppearance;
+    variant: DropdownPanelVariant;
+    private _compact;
+    get compact(): boolean;
+    set compact(v: any);
+    get ngClasses(): string;
+    isOpen: boolean;
+    scrollEvent: EventEmitter<{
+        start: number;
+        end: number;
+    }>;
+    scrollToEndEvent: EventEmitter<any>;
+    onScroll(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    private get _scrollTop();
+    private set _scrollTop(value);
+    private get _scrollBottom();
+    private _scrollToElement;
+    private _currentScrollToDirection;
+    scrollToRecentlyHighlighted(direction: ScrollAlignment): void;
+    private _isElementInView;
+    private _getContentRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumDropdownPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumDropdownPanelComponent, "ard-dropdown-panel", never, { "panelId": { "alias": "panelId"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "scrollEvent": "scroll"; "scrollToEndEvent": "scrollToEnd"; }, never, ["*"], false, never>;
+}

package/lib/dropdown-panel/dropdown-panel.module.d.ts

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

package/lib/dropdown-panel/dropdown-panel.types.d.ts

@@ -0,0 +1,12 @@
+export type ScrollAlignment = 'top' | 'bottom' | 'middle';
+export declare const DropdownPanelAppearance: {
+    readonly Outlined: "outlined";
+    readonly Raised: "raised";
+};
+export type DropdownPanelAppearance = (typeof DropdownPanelAppearance)[keyof typeof DropdownPanelAppearance];
+export declare const DropdownPanelVariant: {
+    readonly Rounded: "rounded";
+    readonly Sharp: "sharp";
+    readonly SharpConnected: "sharp ard-connected";
+};
+export type DropdownPanelVariant = (typeof DropdownPanelVariant)[keyof typeof DropdownPanelVariant];

package/lib/file-inputs/file-drop-area/file-drop-area.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit, TemplateRef } from '@angular/core';
+import { ComponentColor } from '../../types/colors.types';
+import { FormElementVariant } from '../../types/theming.types';
+import { _FileInputComponentBase } from '../file-input-base';
+import { FileInputBrowseContext, FileInputFileAmountContext, FileInputFilesContext } from '../file-input-types';
+import * as i0 from "@angular/core";
+export declare class ArdiumFileDropAreaComponent extends _FileInputComponentBase implements OnInit {
+    variant: FormElementVariant;
+    color: ComponentColor;
+    get ngClasses(): string;
+    protected _wasMousedownOnElement: true | null;
+    onMousedown(): void;
+    onMouseup(): void;
+    idleTemplate: TemplateRef<FileInputBrowseContext> | null;
+    dragoverTemplate: TemplateRef<FileInputFilesContext> | null;
+    uploadedTemplate: TemplateRef<FileInputFilesContext> | null;
+    getIdleContext(): FileInputBrowseContext;
+    getDragoverContext(): FileInputFileAmountContext;
+    getUploadedContext(): FileInputFilesContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFileDropAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumFileDropAreaComponent, "ard-file-drop-area", never, { "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, ["idleTemplate", "dragoverTemplate", "uploadedTemplate"], never, false, never>;
+}

package/lib/file-inputs/file-drop-area/file-drop-area.directives.d.ts

@@ -0,0 +1,21 @@
+import { TemplateRef } from '@angular/core';
+import { FileInputBrowseContext, FileInputFilesContext } from '../file-input-types';
+import * as i0 from "@angular/core";
+export declare class ArdiumFileDropAreaIdleContentTemplateDirective {
+    template: TemplateRef<FileInputBrowseContext>;
+    constructor(template: TemplateRef<FileInputBrowseContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFileDropAreaIdleContentTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumFileDropAreaIdleContentTemplateDirective, "ard-file-drop-area > ng-template[ard-idle-content-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumFileDropAreaDragoverContentTemplateDirective {
+    template: TemplateRef<FileInputFilesContext>;
+    constructor(template: TemplateRef<FileInputFilesContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFileDropAreaDragoverContentTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumFileDropAreaDragoverContentTemplateDirective, "ard-file-drop-area > ng-template[ard-dragover-content-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdiumFileDropAreaUploadedContentTemplateDirective {
+    template: TemplateRef<FileInputFilesContext>;
+    constructor(template: TemplateRef<FileInputFilesContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumFileDropAreaUploadedContentTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumFileDropAreaUploadedContentTemplateDirective, "ard-file-drop-area > ng-template[ard-dropped-content-tmp]", never, {}, {}, never, never, false, never>;
+}