@kirbydesign/designsystem 11.0.0 → 11.1.1

package/chart/index.d.ts

@@ -1,6 +1,200 @@
+import * as chart_js from 'chart.js';
+import { ChartType as ChartType$1, ChartOptions, ChartDataset as ChartDataset$1, ChartConfiguration, TooltipOptions, Plugin } from 'chart.js';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { AnnotationType, AnnotationTypeRegistry, AnnotationOptions } from 'chartjs-plugin-annotation';
+import * as chartjs_plugin_datalabels_types_options from 'chartjs-plugin-datalabels/types/options';
+
+type ChartHighlightedElements = number[][];
+type ChartType = 'column' | 'bar' | 'line' | 'stock';
+type ChartTypeConfig = {
+    type: ChartType$1;
+    options?: ChartOptions;
+};
+type ChartTypesConfig = {
+    [key in ChartType]: ChartTypeConfig;
+};
+type ChartLabel = string | string[];
+type ChartDataLabelOptions = {
+    showMin?: boolean;
+    showMax?: boolean;
+    showCurrent?: boolean;
+    locale?: ChartLocale;
+    valueSuffix?: string;
+};
+type ChartLocale = 'da-DK' | 'en-US';
+type ChartDataset = {
+    kirbyOptions?: {
+        highlightedElements?: number[];
+        isStockChart?: boolean;
+    };
+} & ChartDataset$1;
+declare function isNumberArray(value: any): value is number[];
+
+declare class ChartConfigService {
+    getTypeConfig(chartType: ChartType): ChartTypeConfig;
+    getAnnotationDefaults(type: AnnotationType): AnnotationTypeRegistry[AnnotationType];
+    chartTypeToChartJSType(chartType: ChartType): ChartType$1;
+    applyInteractionFunctionsExtensions(options: ChartOptions): ChartOptions;
+    getStockChartOptions(dataLabelOptions: ChartDataLabelOptions, locale: ChartLocale): {
+        locale: ChartLocale;
+        plugins: {
+            tooltip: {
+                callbacks: {
+                    title: (tooltipItems: any) => any;
+                    label: (context: any) => string;
+                };
+            };
+        };
+        scales: {
+            y: {
+                ticks: {
+                    callback: (value: any) => string;
+                };
+            };
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartConfigService>;
+}
+
+declare class ChartJSService {
+    protected chartConfigService: ChartConfigService;
+    private chart;
+    private highlightedElements;
+    protected chartType: ChartType;
+    private annotationsDelegate;
+    constructor(chartConfigService: ChartConfigService);
+    renderChart(args: {
+        targetElement: ElementRef<HTMLCanvasElement>;
+        type: ChartType;
+        data: ChartDataset[] | number[];
+        labels?: ChartLabel[];
+        customOptions?: ChartOptions;
+        annotations?: AnnotationOptions[];
+        highlightedElements?: ChartHighlightedElements;
+    }): void;
+    redrawChart(): void;
+    destroyChart(): void;
+    updateData(data: ChartDataset[] | number[]): void;
+    updateLabels(labels: ChartLabel[]): void;
+    updateType(type: ChartType, customOptions?: ChartOptions): void;
+    updateOptions(customOptions: ChartOptions, type: ChartType): void;
+    updateAnnotations(annotations: AnnotationOptions[]): void;
+    updateHighlightedElements(highlightedElements?: ChartHighlightedElements): void;
+    protected createOptionsObject(args: {
+        customOptions?: ChartOptions;
+        annotations?: AnnotationOptions[];
+    }): ChartOptions;
+    protected getDefaultLabels(datasets: ChartDataset[]): ChartLabel | ChartLabel[];
+    private createConfigurationObject;
+    protected createDatasets(data: ChartDataset[] | number[]): ChartDataset[];
+    private destructivelyUpdateType;
+    private nonDestructivelyUpdateType;
+    private initializeNewChart;
+    private addHighlightedElementsToDatasets;
+    private getLabelsToApply;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartJSService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartJSService>;
+}
+
+declare const TEST_CHART_TYPES_CONFIG: ChartTypesConfig;
+declare const TEST_CHART_ANNOTATIONS_CONFIG: Omit<AnnotationTypeRegistry, 'label' | 'polygon'>;
+
+declare class BaseChartComponent implements AfterViewInit, OnChanges, OnDestroy {
+    protected chartJSService: ChartJSService;
+    type: ChartType;
+    data: ChartDataset[] | number[];
+    labels: ChartLabel[];
+    customOptions?: ChartOptions;
+    annotations?: AnnotationOptions[];
+    highlightedElements?: ChartHighlightedElements;
+    _height: string;
+    set height(value: string | number);
+    canvasElement: ElementRef<HTMLCanvasElement>;
+    private chartHasBeenRendered;
+    constructor(chartJSService: ChartJSService);
+    ngAfterViewInit(): void;
+    private whenElementHasHeightAndWidth;
+    ngOnChanges(simpleChanges: SimpleChanges): void;
+    protected renderChart(additionalArgs?: any): void;
+    private updateData;
+    private updateLabels;
+    private updateType;
+    private updateCustomOptions;
+    private updateAnnotations;
+    private updateHighlightedElements;
+    private redrawChart;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseChartComponent, "kirby-base-chart", never, { "type": { "alias": "type"; "required": false; }; "data": { "alias": "data"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "customOptions": { "alias": "customOptions"; "required": false; }; "annotations": { "alias": "annotations"; "required": false; }; "highlightedElements": { "alias": "highlightedElements"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ChartComponent extends BaseChartComponent {
+    type: Exclude<ChartType, 'stock'>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent, "kirby-chart", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class StockChartComponent extends BaseChartComponent {
+    dataLabelOptions?: ChartDataLabelOptions;
+    readonly type = "stock";
+    protected renderChart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StockChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StockChartComponent, "kirby-stock-chart", never, { "dataLabelOptions": { "alias": "dataLabelOptions"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ChartsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ChartsModule, [typeof ChartComponent, typeof StockChartComponent], never, [typeof ChartComponent, typeof StockChartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ChartsModule>;
+}
+
+declare class ChartBaseConfig {
+    static baseConfig: ChartConfiguration<ChartType$1>;
+    static tooltipPlugin: Partial<TooltipOptions<'line'>>;
+    static registerPlugins: () => void;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * This class is still experimental. Feel free to use it, but please note that it is still subject to breaking changes.
  */
-/// <amd-module name="@kirbydesign/designsystem/chart" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-chart.d.ts.map
+declare class BarChartConfig extends ChartBaseConfig {
+    private static BAR_CHART_LOCALE_DEFAULT;
+    static baseConfig: ChartConfiguration<ChartType$1>;
+}
+
+interface VerticalLinePlugin extends Plugin {
+    id: string;
+    drawTime: string;
+    line?: {
+        color: string;
+    };
+    defaults?: {
+        width: number;
+        color: string;
+    };
+}
+
+/**
+ * This class is still experimental. Feel free to use it, but please note that it is still subject to breaking changes.
+ */
+declare class StockChartConfig extends ChartBaseConfig {
+    private static STOCK_CHART_LOCALE_DEFAULT;
+    private static scales;
+    private static elements;
+    private static controllers;
+    private static plugins;
+    private static registeredElements;
+    private static pluginsRegistered;
+    static registerPlugins(): void;
+    static baseConfig: ChartConfiguration<ChartType$1>;
+    static tooltipPlugin: Partial<TooltipOptions<'line'>>;
+    static dataLabelsPluginConfig: Partial<chartjs_plugin_datalabels_types_options.Options>;
+    static verticalLinePluginConfig: VerticalLinePlugin;
+    static getDataLabelPosition: (data: chart_js.ScatterDataPoint[], dataIndex: number) => chartjs_plugin_datalabels_types_options.Align | null;
+}
+
+export { BarChartConfig, BaseChartComponent, ChartComponent, ChartConfigService, ChartJSService, ChartsModule, StockChartComponent, StockChartConfig, TEST_CHART_ANNOTATIONS_CONFIG, TEST_CHART_TYPES_CONFIG, isNumberArray };
+export type { ChartDataLabelOptions, ChartDataset, ChartHighlightedElements, ChartLabel, ChartLocale, ChartType, ChartTypeConfig, ChartTypesConfig };
+//# sourceMappingURL=index.d.ts.map

package/chart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../chart/src/shared/charts.types.ts","../../chart/src/shared/chart-config-service/chart-config.service.ts","../../chart/src/shared/chart-js-service/chart-js.service.ts","../../chart/src/shared/chart-js-service/test-utils.ts","../../chart/src/shared/base-chart/base-chart.component.ts","../../chart/src/chart/chart.component.ts","../../chart/src/stock-chart/stock-chart.component.ts","../../chart/src/charts.module.ts","../../chart/src/chart-config/chart-base-config.ts","../../chart/src/chart-config/chart-bar-config/chart-bar-config.ts","../../chart/src/chart-config/chart-stock-config/vertical-line-plugin/vertical-line-plugin.model.ts","../../chart/src/chart-config/chart-stock-config/chart-stock-config.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;AAIM;AAEA;;;;AAEA;;;;AAKA;;;;;;;;AAcA;AACJ;AAAiB;;;AAClB;AAED;;ACpBA;AAES;;AAaA;AAIA;AAWA;;;;;;;;;;;;;;;;;;;;AAoCR;;AC5DD;;;;AAIE;;AAGsB;;AAKpB;;AAEA;AACA;;AAEA;;AAED;;;;AAgCM;;AAgBA;AAMA;AAMA;AAcP;;AAEE;AACD;;AA6BD;AAoBA;AASA;AAcA;AAeA;AAIA;AAmBA;;;AAiCD;;AC7PD;AA2JA;;AC5IA;;;AAQW;;;AAKA;;;AAKT;AAKA;;AAIsB;;AAatB;;AAyCA;AAcA;AAIA;AAIA;AAIA;AAIA;AAIA;AAIA;;;;AAOD;;AC5ID;AAQW;;;AACV;;ACPD;;;AAYE;;;AAGD;;ACfD;;;;AAK4B;;ACT5B;AACE;;AAEA;AACD;;ACED;;AAEG;AACH;AACE;AAEA;AAiCD;;AC7CK;;;AAGJ;;;AAGA;;;;AAID;;ACsBD;;AAEG;AACH;AACE;AAEA;AACA;AACA;AACA;AACA;AAOA;;AAaA;;AA4GA;AAEA;AAEA;AACD;;;"}

package/checkbox/index.d.ts

@@ -1,6 +1,69 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/checkbox" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-checkbox.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnInit, AfterContentInit, EventEmitter, ElementRef, ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { IonicElementPartHelper } from '@kirbydesign/designsystem/helpers';
+
+declare class CheckboxComponent implements AfterViewInit, ControlValueAccessor, OnInit, AfterContentInit {
+    private element;
+    private ionicElementPartHelper;
+    private cdr;
+    private ionCheckboxElement?;
+    checked: boolean;
+    indeterminate: boolean;
+    attentionLevel: '1' | '2';
+    text: string;
+    size: 'xs' | 'sm' | 'md';
+    hasError: boolean;
+    disabled: boolean;
+    get _isDisabled(): string;
+    get isAttentionLevel1(): boolean;
+    get isAttentionLevel2(): boolean;
+    _labelText: string;
+    checkedChange: EventEmitter<boolean>;
+    _justify: 'start' | 'end' | 'space-between';
+    _labelPlacement: 'end' | 'fixed' | 'stacked' | 'start';
+    _hasSlottedContent: boolean;
+    constructor(element: ElementRef<HTMLElement>, ionicElementPartHelper: IonicElementPartHelper, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    onChecked(checked: boolean): void;
+    onBlur(): void;
+    private _onChange;
+    private _onTouched;
+    /**
+     * Sets the checkbox's value. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param value New value to be written to the model.
+     */
+    writeValue(value: boolean): void;
+    /**
+     * Saves a callback function to be invoked when the checkbox's value
+     * changes from user input. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the value changes.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Saves a callback function to be invoked when the checkbox is blurred
+     * by the user. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the component has been touched.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Disables the checkbox. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param isDisabled Sets whether the component is disabled.
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "kirby-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "attentionLevel": { "alias": "attentionLevel"; "required": false; }; "text": { "alias": "text"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+export { CheckboxComponent };
+//# sourceMappingURL=index.d.ts.map

package/checkbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../checkbox/src/checkbox.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAqBA,cAAA,iBAAA,YAAA,aAAA,EAAA,oBAAA,EAAA,MAAA,EAAA,gBAAA;AA0DI;AACA;AACA;;;;AArCO;;AAOT;;AAMS;AACT;AAKA;AAGA;;AAMU,mBAAA,YAAA;AAEV;;;AAKU,yBAAA,UAAA,CAAA,WAAA,2BAAA,sBAAA,OAAA,iBAAA;AAKV;AAiBA;AAcA;AASA;;;;AAgBA;;;;;AAKG;AACH;AAKA;;;;;;AAMG;AACH;AAIA;;;;;;AAMG;AACH;AAIA;;;;;AAKG;AACH;;;AAGD;;;;"}

package/config/index.d.ts

@@ -1,6 +1,42 @@
+import { Provider, EnvironmentProviders, InjectionToken } from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * Configuration object for global configuration of Kirby.
  */
-/// <amd-module name="@kirbydesign/designsystem/config" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-config.d.ts.map
+interface KirbyConfig {
+    moduleRootRoutePath?: string;
+    /**
+     * Activate focus management for components rendered in a kirby-router-outlet.
+     * When a kirby-page enters the view, focus will be set to the pages primary heading (h1) inside the pages toolbar.
+     */
+    focusManager?: boolean;
+    /**
+     * Set the HTML documents title to match the title of any kirby-page entering the view.
+     */
+    setHtmlDocTitle?: boolean;
+}
+/**
+ * Injection token for provided Kirby configuration.
+ */
+declare const KIRBY_CONFIG: InjectionToken<KirbyConfig>;
+/**
+ *
+ * @param features - Additional features to be provided to the Kirby environment:
+ * @see {@link withGlobalSetup} for setting up global configuration.
+ */
+declare function provideKirby(...features: Provider[] | EnvironmentProviders[]): EnvironmentProviders;
+/**
+ * Sets up global configuration when used with the provideKirby EnvironmentProvider function.
+ * Should be called exactly once per application when bootstrapping, to set up Kirby in the browsers runtime.
+ *
+ * @param config - (Optional) Additional configuration via the `KirbyConfig` object.
+ */
+declare function withGlobalSetup(config?: KirbyConfig): EnvironmentProviders;
+/**
+ * Retrieves the global Kirby configuration object from the window object.
+ */
+declare function getGlobalConfig(): KirbyConfig | undefined;
+
+export { KIRBY_CONFIG, getGlobalConfig, provideKirby, withGlobalSetup };
+export type { KirbyConfig };
+//# sourceMappingURL=index.d.ts.map

package/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../config/src/provide-kirby.ts"],"sourcesContent":[null],"names":[],"mappings":";;AA4BA;;AAEG;;;AAID;;;AAGG;;AAGH;;AAEG;;AAEJ;AAED;;AAEG;AACH;AAEA;;;;AAIG;AACH;AAmBA;;;;;AAKG;AACH;AAcA;;AAEG;AACH;;;"}

package/data-table/index.d.ts

@@ -1,6 +1,32 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, Renderer2, ElementRef } from '@angular/core';
+
+declare class TableSortableComponent implements AfterViewInit {
+    private renderer;
+    constructor(renderer: Renderer2);
+    sortable: boolean;
+    active: boolean;
+    sortDirection: 'asc' | 'desc';
+    iconAlignment: 'start' | 'end';
+    alignment: 'start' | 'center' | 'end';
+    get isActive(): boolean;
+    _getAlignmentClasses(): string[];
+    spanElement: ElementRef;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableSortableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableSortableComponent, "th[sortable]", never, { "sortable": { "alias": "sortable"; "required": false; }; "active": { "alias": "active"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "iconAlignment": { "alias": "iconAlignment"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated 'DataTableModule' has been deprecated in favor of the standalone 'TableSortableComponent'.
+ * Please import 'TableSortableComponent' instead. 'DataTableModule' will be removed in Kirby v11.
  */
-/// <amd-module name="@kirbydesign/designsystem/data-table" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-data-table.d.ts.map
+declare class DataTableModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DataTableModule, never, [typeof TableSortableComponent], [typeof TableSortableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DataTableModule>;
+}
+
+export { DataTableModule, TableSortableComponent };
+//# sourceMappingURL=index.d.ts.map

package/data-table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../data-table/src/sortable/sortable.component.ts","../../data-table/src/data-table.module.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAcA,cAAA,sBAAA,YAAA,aAAA;AASc;AAAQ,0BAAA,SAAA;AAIpB;AAES;AAEA;AACA;AACA;AAET;;;AAmBA;;;AASD;;AC5DD;;;AAGG;AACH,cAAA,eAAA;;;;;AASC;;;;"}

package/divider/index.d.ts

@@ -1,6 +1,10 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/divider" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-divider.d.ts.map
+import * as i0 from '@angular/core';
+
+declare class DividerComponent {
+    hasMargin: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DividerComponent, "kirby-divider", never, { "hasMargin": { "alias": "hasMargin"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { DividerComponent };
+//# sourceMappingURL=index.d.ts.map

package/divider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../divider/src/divider.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA,cAAA,gBAAA;;;;AASC;;;;"}

package/dropdown/index.d.ts

@@ -1,6 +1,166 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/dropdown" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-dropdown.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter, TemplateRef, QueryList, ElementRef, Renderer2, ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i6 from '@kirbydesign/designsystem/popover';
+import { HorizontalDirection, PopoverComponent } from '@kirbydesign/designsystem/popover';
+import { ResizeObserverService } from '@kirbydesign/designsystem/shared';
+import * as i2 from '@kirbydesign/designsystem/card';
+import * as i3 from '@kirbydesign/designsystem/icon';
+import * as i4 from '@kirbydesign/designsystem/item';
+import * as i5 from '@kirbydesign/designsystem/form-field';
+import * as i7 from '@kirbydesign/designsystem/button';
+import * as i8 from '@angular/common';
+import * as i9 from '@kirbydesign/designsystem/list';
+
+declare class KeyboardHandlerService {
+    handle(event: KeyboardEvent, selectedIndex: number, maxIndex: number, cyclicIndex?: boolean): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeyboardHandlerService>;
+}
+
+declare class DropdownComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    private renderer;
+    private elementRef;
+    private changeDetectorRef;
+    private keyboardHandlerService;
+    private resizeObserverService;
+    static readonly OPEN_DELAY_IN_MS = 100;
+    private state;
+    private horizontalDirection;
+    private verticalDirection;
+    private _attributesToForward;
+    _listboxId: string;
+    _comboboxId: string;
+    private _items;
+    get items(): string[] | any[];
+    set items(value: string[] | any[]);
+    private _selectedIndex;
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    private _focusedIndex;
+    get focusedIndex(): number;
+    set focusedIndex(value: number);
+    itemTextProperty: string;
+    placeholder: string;
+    set popout(direction: HorizontalDirection | `${HorizontalDirection}`);
+    get popout(): HorizontalDirection | `${HorizontalDirection}`;
+    attentionLevel: '1' | '2' | '3';
+    expand?: 'block';
+    disabled: boolean;
+    get _isDisabled(): string;
+    hasError: boolean;
+    size: 'sm' | 'md';
+    tabindex: number;
+    usePopover: boolean;
+    get _tabindex(): number;
+    get _noBlurOnScroll(): boolean;
+    /**
+     * Emitted when an item is selected (tap on mobile, click/keypress on web)
+     */
+    change: EventEmitter<string | any>;
+    private _value;
+    get value(): string | any;
+    get selectedText(): string;
+    get _isBlockLevel(): boolean;
+    get _isOpening(): boolean;
+    get isOpen(): boolean;
+    get _popoutLeft(): boolean;
+    get _popoutUp(): boolean;
+    clicked: boolean;
+    itemTemplate: TemplateRef<any>;
+    slottedItems: QueryList<ElementRef<HTMLElement>>;
+    cardElement: ElementRef<HTMLElement>;
+    popover?: PopoverComponent;
+    buttonElement: ElementRef<HTMLElement>;
+    private forwardAriaLabelToDropdownButton;
+    kirbyItemsDefault: QueryList<ElementRef<HTMLElement>>;
+    _kirbyItemsSlotted: QueryList<ElementRef<HTMLElement>>;
+    set kirbyItemsSlotted(kirbyItems: QueryList<ElementRef<HTMLElement>>);
+    get kirbyItemsSlotted(): QueryList<ElementRef<HTMLElement>>;
+    private itemClickUnlisten;
+    private intersectionObserverRef;
+    private showDropdownTimeoutId;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef, keyboardHandlerService: KeyboardHandlerService, resizeObserverService: ResizeObserverService);
+    onToggle(event: MouseEvent): void;
+    toggle(): void;
+    onButtonMouseEvent(event: Event): void;
+    private setPopoverCardStyle;
+    ngAfterViewInit(): void;
+    private initializeAlignment;
+    private setHorizontalDirection;
+    private setVerticalDirection;
+    open(): void;
+    private showDropdown;
+    close(): void;
+    onItemSelect(index: number): void;
+    private _onChange;
+    private _onTouched;
+    /**
+     * Sets the select's value. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param value New value to be written to the model.
+     */
+    writeValue(value: any): void;
+    /**
+     * Saves a callback function to be invoked when the select's value
+     * changes from user input. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the value changes.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Saves a callback function to be invoked when the select is blurred
+     * by the user. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the component has been touched.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Disables the select. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param isDisabled Sets whether the component is disabled.
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    private selectItem;
+    private _selectItemByValue;
+    getTextFromItem(item: string | any): any;
+    scrollItemIntoView(index: number): void;
+    _onTab(event: KeyboardEvent): void;
+    _onMouseDown(event: MouseEvent): void;
+    _onTouchStart(event: TouchEvent): void;
+    _onFocus(): void;
+    _onPopoverWillHide(): void;
+    _onEnterOrEscape(): void;
+    _onPopoverClick(): void;
+    _onBlur(): void;
+    _onEnterOrSpace(event: KeyboardEvent): void;
+    _onArrowKeys(event: KeyboardEvent): boolean;
+    _onHomeEndKeys(event: KeyboardEvent): boolean;
+    private unlistenAllSlottedItems;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "kirby-dropdown", never, { "items": { "alias": "items"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "focusedIndex": { "alias": "focusedIndex"; "required": false; }; "itemTextProperty": { "alias": "itemTextProperty"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "popout": { "alias": "popout"; "required": false; }; "attentionLevel": { "alias": "attentionLevel"; "required": false; }; "expand": { "alias": "expand"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "size": { "alias": "size"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "usePopover": { "alias": "usePopover"; "required": false; }; }, { "change": "change"; }, ["itemTemplate", "slottedItems", "kirbyItemsSlotted"], never, false, never>;
+}
+
+declare class DropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DropdownModule, [typeof DropdownComponent], [typeof i2.CardModule, typeof i3.IconModule, typeof i4.ItemModule, typeof i5.FormFieldModule, typeof i6.PopoverComponent, typeof i7.ButtonComponent, typeof i8.CommonModule, typeof i9.ListModule], [typeof DropdownComponent, typeof i9.ListItemTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DropdownModule>;
+}
+
+declare enum OpenState {
+    closed = 0,
+    opening = 1,
+    open = 2
+}
+declare enum VerticalDirection {
+    up = 0,
+    down = 1
+}
+
+export { DropdownComponent, DropdownModule, KeyboardHandlerService, OpenState, VerticalDirection };
+//# sourceMappingURL=index.d.ts.map

package/dropdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../dropdown/src/keyboard-handler.service.ts","../../dropdown/src/dropdown.component.ts","../../dropdown/src/dropdown.module.ts","../../dropdown/src/dropdown.types.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;AAEA,cAAA,sBAAA;AAIE,kBAAA,aAAA;;;AAmCD;;ACPD,cAAA,iBAAA,YAAA,aAAA,EAAA,SAAA,EAAA,oBAAA;AA+NI;AACA;AACA;AACA;AACA;AArNF;;;;;AAOA;AACA;;AAIA;;;;AAcA;;;AAeA;AAQA;AAGA;;AAMA,kBAAA,mBAAA,MAAA,mBAAA;AAKA;;AAMA;AAEA;;AAUA;AAGA;AAIA;AAEA;AAKA;AAKA;;AAEG;AACO,YAAA,YAAA;;AAGV;;AAQA;;;AAeA;AAKA;AAgBA;AAGA,kBAAA,WAAA;;AAIA,iBAAA,UAAA,CAAA,WAAA;;AAIA,mBAAA,UAAA,CAAA,WAAA;AAEA;;;;;;;;;;;;AA8EA;;AAiCA;AAmCA;AAcA;;AAoCA;;;;;AA6BA;;;;;AAKG;AACH;AAIA;;;;;;AAMG;AACH;AAIA;;;;;;AAMG;AACH;AAIA;;;;;AAKG;AACH;AAIA;AASA;AAIA;;;;;;;;;;;;;AA8JA;AAOA;;;AAOD;;ACvoBD,cAAA,cAAA;;;;AAe8B;;AC/B9B,aAAA,SAAA;AACE;AACA;AACA;AACD;AAED,aAAA,iBAAA;AACE;AACA;AACD;;;;"}

package/empty-state/index.d.ts

@@ -1,6 +1,37 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/empty-state" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-empty-state.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnInit, ElementRef, Renderer2 } from '@angular/core';
+import * as i2 from '@kirbydesign/designsystem/icon';
+import * as i3 from '@angular/common';
+import * as i4 from '@kirbydesign/designsystem/shared';
+
+declare class EmptyStateComponent implements AfterContentInit, OnInit {
+    private elementRef;
+    private renderer;
+    private _title;
+    private ionModalDialog;
+    iconName: string;
+    set title(value: string);
+    get title(): string;
+    _insideModal: boolean;
+    subtitle: string;
+    private slottedButtons;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /** Enforces that all slotted buttons will have their attention
+     * level set to 3, except the first button if it has
+     * level 1.
+     */
+    private enforceAttentionLevelRules;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateComponent, "kirby-empty-state", never, { "iconName": { "alias": "iconName"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; }, {}, ["slottedButtons"], ["*"], false, never>;
+}
+
+declare class EmptyStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EmptyStateModule, [typeof EmptyStateComponent], [typeof i2.IconModule, typeof i3.CommonModule, typeof i4.ThemeColorDirective], [typeof EmptyStateComponent, typeof i4.ThemeColorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EmptyStateModule>;
+}
+
+export { EmptyStateComponent, EmptyStateModule };
+//# sourceMappingURL=index.d.ts.map

package/empty-state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../empty-state/src/empty-state.component.ts","../../empty-state/src/empty-state.module.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;AAcA,cAAA,mBAAA,YAAA,gBAAA,EAAA,MAAA;AAgCI;AACA;;;;AApBF;;;;;;AAuBA;;AAsBA;;;AAGG;AACH;;;AAWD;;AC/ED,cAAA,gBAAA;;;;AAKgC;;;;"}