@kirbydesign/designsystem 11.0.0 → 11.1.1

package/page/index.d.ts

@@ -1,6 +1,235 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit, AfterContentChecked, OnChanges, EventEmitter, ElementRef, TemplateRef, QueryList, Injector, Renderer2, ChangeDetectorRef, NgZone, SimpleChanges, InjectionToken } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i7 from '@ionic/angular/standalone';
+import { IonRouterOutlet, NavController } from '@ionic/angular/standalone';
+import { Title } from '@angular/platform-browser';
+import { TabsComponent } from '@kirbydesign/designsystem/tabs';
+import * as i6 from '@kirbydesign/designsystem/header';
+import { HeaderComponent, HeaderActionsDirective, HeaderTitleActionIconDirective } from '@kirbydesign/designsystem/header';
+import { IonicElementPartHelper } from '@kirbydesign/designsystem/helpers';
+import { ModalNavigationService, ModalElementComponent, ModalElementsAdvertiser } from '@kirbydesign/designsystem/modal';
+import * as i4 from '@kirbydesign/designsystem/shared';
+import { TranslationService, FitHeadingConfig, ResizeObserverService } from '@kirbydesign/designsystem/shared';
+import * as i3 from '@angular/common';
+import * as i5 from '@kirbydesign/designsystem/spinner';
+
+type stickyConfig = {
+    sticky: boolean;
+};
+type fixedConfig = {
+    fixed: boolean;
+};
+type MaxWidth = 'default' | 'lg' | 'xl' | 'full';
+declare const PAGE_BACK_BUTTON_OVERRIDE: InjectionToken<PageBackButtonOverride>;
+interface PageBackButtonOverride {
+    navigateBack: (routerOutlet: IonRouterOutlet, navCtrl: NavController, defaultBackHref: string) => void;
+}
 /**
- * Generated bundle index. Do not edit.
+ * Event emitted when "pull-to-refresh" begins.
  */
-/// <amd-module name="@kirbydesign/designsystem/page" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-page.d.ts.map
+interface PullToRefreshEvent {
+    /**
+     * Invoke this callback-method when action to perform upon "pull-to-refresh" completes.
+     */
+    complete(): any;
+}
+declare class PageTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageTitleDirective, "[kirbyPageTitle]", never, {}, {}, never, never, false, never>;
+}
+declare class PageSubtitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageSubtitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageSubtitleDirective, "[kirbyPageSubtitle]", never, {}, {}, never, never, false, never>;
+}
+declare class PageToolbarTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageToolbarTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageToolbarTitleDirective, "[kirbyPageToolbarTitle]", never, {}, {}, never, never, false, never>;
+}
+declare class PageActionsDirective {
+    template: TemplateRef<any>;
+    config: stickyConfig | fixedConfig;
+    private readonly stickyDefault;
+    private readonly fixedDefault;
+    constructor(template: TemplateRef<any>);
+    get isSticky(): boolean;
+    get isFixed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageActionsDirective, "[kirbyPageActions]", never, { "config": { "alias": "kirbyPageActions"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class PageContentDirective {
+    template: TemplateRef<any>;
+    config: fixedConfig;
+    constructor(template: TemplateRef<any>);
+    get isFixed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageContentDirective, "[kirbyPageContent]", never, { "config": { "alias": "kirbyPageContent"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class PageStickyContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageStickyContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageStickyContentDirective, "[kirbyPageStickyContent]", never, {}, {}, never, never, false, never>;
+}
+declare class PageProgressComponent extends ModalElementComponent {
+    slot: string;
+    constructor(modalElementsAdvertiser: ModalElementsAdvertiser, elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageProgressComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageProgressComponent, "kirby-page-progress", never, {}, {}, never, ["*"], false, never>;
+}
+declare class PageTitleComponent extends ModalElementComponent {
+    constructor(elementRef: ElementRef<HTMLElement>, modalElementsAdvertiser: ModalElementsAdvertiser);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageTitleComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageTitleComponent, "kirby-page-title", never, {}, {}, never, ["*"], false, never>;
+}
+declare class PageContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageContentComponent, "kirby-page-content", never, {}, {}, never, ["*"], false, never>;
+}
+declare class PageActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageActionsComponent, "kirby-page-actions", never, {}, {}, never, ["button[kirby-button]"], false, never>;
+}
+declare class PageComponent implements OnInit, OnDestroy, AfterViewInit, AfterContentChecked, OnChanges {
+    private elementRef;
+    private injector;
+    private renderer;
+    private router;
+    private changeDetectorRef;
+    private zone;
+    private modalNavigationService;
+    private resizeObserverService;
+    private tabsComponent;
+    private backButtonOverride;
+    private routerOutlet;
+    private navCtrl;
+    private ionicElementPartHelper;
+    translations: TranslationService;
+    private htmlDocTitle;
+    title: string;
+    subtitle: string;
+    toolbarTitle: string;
+    titleAlignment: 'left' | 'center' | 'right';
+    defaultBackHref: string;
+    hideBackButton: boolean;
+    titleMaxLines: number;
+    hasInteractiveTitle: boolean;
+    set maxWidth(width: MaxWidth);
+    get maxWidth(): MaxWidth;
+    private _maxWidth;
+    private _tabBarBottomHidden;
+    get tabBarBottomHidden(): boolean;
+    set tabBarBottomHidden(value: boolean);
+    enter: EventEmitter<void>;
+    leave: EventEmitter<void>;
+    refresh: EventEmitter<PullToRefreshEvent>;
+    backButtonClick: EventEmitter<Event>;
+    toolbarTitleClick: EventEmitter<PointerEvent>;
+    private content?;
+    private ionContentElement;
+    ionHeaderElement: ElementRef<HTMLIonHeaderElement>;
+    private ionFooterElement;
+    private ionToolbarElement;
+    private ionToolbarButtonsElement;
+    private backButton;
+    private pageTitle;
+    private stickyContentContainer;
+    private simpleTitleTemplate;
+    private simpleToolbarTitleTemplate;
+    private customToolbarTitleTemplate;
+    customTitleTemplate: TemplateRef<any>;
+    customSubtitleTemplate: TemplateRef<any>;
+    customActions: QueryList<PageActionsDirective>;
+    private customContent;
+    private stickyContentRef;
+    header?: HeaderComponent;
+    hasHeader: boolean;
+    hasPageTitle: boolean;
+    hasPageSubtitle: boolean;
+    toolbarTitleVisible: boolean;
+    toolbarActionsVisible: boolean;
+    isContentScrolled: boolean;
+    isStickyContentPinned: boolean;
+    fitHeadingConfig: FitHeadingConfig;
+    toolbarTitleTemplate: TemplateRef<any>;
+    customContentTemplate: TemplateRef<any>;
+    pageActionsTemplate: TemplateRef<any>;
+    fixedContentTemplate: TemplateRef<any>;
+    stickyActionsTemplate: TemplateRef<any>;
+    fixedActionsTemplate: TemplateRef<any>;
+    stickyContentTemplate: TemplateRef<PageStickyContentDirective>;
+    headerActionsTemplate: TemplateRef<HeaderActionsDirective>;
+    titleActionIconTemplate: TemplateRef<HeaderTitleActionIconDirective>;
+    private titleIntersectionObserver?;
+    private stickyActionsIntersectionObserver?;
+    private stickyContentIntersectionObserver?;
+    private isObservingTitle;
+    private isObservingActions;
+    private isDocTitleSet;
+    private unobserveTitleMutation;
+    private url;
+    private isActive;
+    private ngOnDestroy$;
+    private contentScrolled$;
+    private navigationStart$;
+    private navigationEnd$;
+    toolbarActionGroupInjector: Injector;
+    constructor(elementRef: ElementRef, injector: Injector, renderer: Renderer2, router: Router, changeDetectorRef: ChangeDetectorRef, zone: NgZone, modalNavigationService: ModalNavigationService, resizeObserverService: ResizeObserverService, tabsComponent: TabsComponent, backButtonOverride: PageBackButtonOverride, routerOutlet: IonRouterOutlet, navCtrl: NavController, ionicElementPartHelper: IonicElementPartHelper, translations: TranslationService, htmlDocTitle: Title);
+    private contentReadyPromise;
+    private whenContentReady;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    delegateRefreshEvent(event: any): void;
+    getMaxWidthClasses(): string;
+    onTitleClick(event: PointerEvent): void;
+    private removeWrapper;
+    private onEnter;
+    private onLeave;
+    private interceptBackButtonClicksSetup;
+    private patchIonLastFocused;
+    private initializeStickyIntersectionObserver;
+    private initializeHeader;
+    private initializeTitle;
+    private observeTitle;
+    private unobserveTitle;
+    private observeTitleDOMChanges;
+    private setHTMLDocumentTitle;
+    private initializeActions;
+    private observeActions;
+    private unobserveActions;
+    private setActionButtonsWidth;
+    private initializeContent;
+    private initializeStickyContent;
+    private createStickyContentIntersectionObserver;
+    private getPathname;
+    _onKeyboardWillShow(info?: {
+        keyboardHeight: number;
+    }): void;
+    _onKeyboardWillHide(): void;
+    _onSelectedTabClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, [null, null, null, null, null, null, null, null, { optional: true; skipSelf: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "kirby-page", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "toolbarTitle": { "alias": "toolbarTitle"; "required": false; }; "titleAlignment": { "alias": "titleAlignment"; "required": false; }; "defaultBackHref": { "alias": "defaultBackHref"; "required": false; }; "hideBackButton": { "alias": "hideBackButton"; "required": false; }; "titleMaxLines": { "alias": "titleMaxLines"; "required": false; }; "hasInteractiveTitle": { "alias": "hasInteractiveTitle"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "tabBarBottomHidden": { "alias": "tabBarBottomHidden"; "required": false; }; }, { "enter": "enter"; "leave": "leave"; "refresh": "refresh"; "backButtonClick": "backButtonClick"; "toolbarTitleClick": "toolbarTitleClick"; }, ["customToolbarTitleTemplate", "customTitleTemplate", "customSubtitleTemplate", "stickyContentRef", "header", "customActions", "customContent"], ["kirby-header", "kirby-page-footer", "kirby-page-actions", "kirby-page-content"], false, never>;
+}
+
+declare class PageFooterComponent implements OnDestroy {
+    private pageComponent;
+    private hostElement;
+    private renderer;
+    hasPadding: boolean;
+    constructor(pageComponent: PageComponent, hostElement: ElementRef, renderer: Renderer2);
+    close(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageFooterComponent, [{ optional: true; skipSelf: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageFooterComponent, "kirby-page-footer", never, { "hasPadding": { "alias": "hasPadding"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class PageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PageModule, [typeof PageComponent, typeof PageActionsComponent, typeof PageActionsDirective, typeof PageContentComponent, typeof PageFooterComponent, typeof PageContentDirective, typeof PageProgressComponent, typeof PageTitleComponent, typeof PageTitleDirective, typeof PageSubtitleDirective, typeof PageToolbarTitleDirective, typeof PageStickyContentDirective], [typeof i3.CommonModule, typeof i4.FitHeadingDirective, typeof i5.SpinnerModule, typeof i6.HeaderModule, typeof i7.IonHeader, typeof i7.IonToolbar, typeof i7.IonButtons, typeof i7.IonBackButton, typeof i7.IonContent, typeof i7.IonTitle, typeof i7.IonRefresher, typeof i7.IonFooter], [typeof PageComponent, typeof PageActionsComponent, typeof PageActionsDirective, typeof PageContentComponent, typeof PageFooterComponent, typeof PageContentDirective, typeof PageProgressComponent, typeof PageTitleComponent, typeof PageTitleDirective, typeof PageSubtitleDirective, typeof PageToolbarTitleDirective, typeof i4.FitHeadingDirective, typeof PageStickyContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PageModule>;
+}
+
+export { PAGE_BACK_BUTTON_OVERRIDE, PageActionsComponent, PageActionsDirective, PageComponent, PageContentComponent, PageContentDirective, PageFooterComponent, PageModule, PageProgressComponent, PageStickyContentDirective, PageSubtitleDirective, PageTitleComponent, PageTitleDirective, PageToolbarTitleDirective };
+export type { PageBackButtonOverride, PullToRefreshEvent };
+//# sourceMappingURL=index.d.ts.map

package/page/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../page/src/page.component.ts","../../page/src/page-footer/page-footer.component.ts","../../page/src/page.module.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;;;AA+EA;;;AACA;;;AACA;AAEA;;AAKE;AAKD;AAED;;AAEG;;AAED;;AAEG;AACH;AACD;AAED;;;AAIkC;AAElC;;;AAIqC;AAErC;;;AAIyC;AAEzC;AASqB;AAJQ;AAC3B;AACA;AAEmB;;;;;AAapB;AAED;AAOqB;;AAAA;;;;AAKpB;AAED;;;AAI0C;AAE1C;AAkB4B;;;;AAQ3B;AACD;;;;AAcC;AAED;;;AAOoC;AAEpC;;;AAeoC;AAEpC;AAyII;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACwB;AAGxB;AAEA;AAEA;AACA;AACO;AACP;;;;AA7IO;;;;;AAMT;;;;;AAcA;AAYU;AACA;AACA;AACA;AACA;;;AAMV;;;;;;;;;;AAqBA;AAEA;AAEA;;;;;;;;;;AAcA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AAoDA;AAcA;AAuBA;AAeA;AA0CA;AASA;AAUA;;;AAwBA;AAQA;AAcA;AAeA;AAmBA;AAaA;AAYA;AAmBA;AA4CA;AA6CA;AAQA;AAgBA;AAOA;AAwBA;AA6CA;AAOA;AAiCA;AAUA;AAIA;AAeA;;;AAKqD;;;;;AAoBtD;;ACt4BD;AAY4B;AACxB;AACA;;;;AAgBF;;;AAGD;;ACfD;;;;AA6C0B;;;"}

package/popover/index.d.ts

@@ -1,6 +1,40 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/popover" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-popover.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, EventEmitter, Renderer2 } from '@angular/core';
+
+declare enum HorizontalDirection {
+    right = "right",
+    left = "left"
+}
+declare class PopoverComponent implements AfterViewInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    private readonly preventScrollEventListenerOptions;
+    private readonly POPOVER_BODY_PADDING;
+    private isShowing;
+    private isFirstToLockScroll;
+    private zIndex;
+    private document;
+    wrapperElement: ElementRef<HTMLDivElement>;
+    popout: HorizontalDirection | `${HorizontalDirection}`;
+    target: HTMLElement | ElementRef<HTMLElement>;
+    willHide: EventEmitter<void>;
+    private get targetElement();
+    _onWindowResize(): void;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private placePopoverAboveClosestModal;
+    private static preventEventOutsidePopover;
+    private preventScroll;
+    private releaseScroll;
+    show(): void;
+    hide(): void;
+    private positionWrapper;
+    private positionHorizontally;
+    private positionVertically;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "kirby-popover", never, { "popout": { "alias": "popout"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, { "willHide": "willHide"; }, never, ["*"], true, never>;
+}
+
+export { HorizontalDirection, PopoverComponent };
+//# sourceMappingURL=index.d.ts.map

package/popover/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../popover/src/popover.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAcA,aAAA,mBAAA;AACE;AACA;AACD;AAED,cAAA,gBAAA,YAAA,aAAA,EAAA,SAAA;AA8CI;AACA;AAtCF;AAIA;;;;;AAQA,oBAAA,UAAA,CAAA,cAAA;AAGA,YAAA,mBAAA,MAAA,mBAAA;AAGA,YAAA,WAAA,GAAA,UAAA,CAAA,WAAA;AAGA,cAAA,YAAA;;;;AAsBA;AAQA;AAIA;;AAoBA;AAcA;;;AAwCA;AAYA;AA0BA;;;AA+BD;;;;"}

package/progress-circle/index.d.ts

@@ -1,6 +1,64 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/progress-circle" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-progress-circle.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef } from '@angular/core';
+
+declare class ProgressCircleComponent implements AfterViewInit, OnDestroy {
+    private elementRef;
+    private changeDetectorRef;
+    readonly SIZE_CONFIG: {
+        sm: {
+            diameter: number;
+            strokeWidth: number;
+            upperBound: number;
+        };
+        md: {
+            diameter: number;
+            strokeWidth: number;
+            upperBound: number;
+        };
+        lg: {
+            diameter: number;
+            strokeWidth: number;
+            upperBound: number;
+        };
+    };
+    readonly role = "progressbar";
+    value: number;
+    size: 'sm' | 'md' | 'lg';
+    themeColor: 'success' | 'warning' | 'danger';
+    get _cssSize(): "sm" | "md" | "lg";
+    private hasElementBeenVisible?;
+    private observer;
+    constructor(elementRef: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private onIntersectionChange;
+    private unobserve;
+    get _diameter(): number;
+    get _shownValue(): number;
+    get _radius(): number;
+    get _strokeWidth(): number;
+    get _upperBound(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressCircleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressCircleComponent, "kirby-progress-circle", never, { "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; }; "themeColor": { "alias": "themeColor"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ProgressCircleRingComponent implements AfterViewInit {
+    radius: number;
+    value: number;
+    themeColor: 'success' | 'warning' | 'danger';
+    strokeWidth: number;
+    upperBound: number;
+    viewInitialized: any;
+    ngAfterViewInit(): void;
+    get _diameter(): number;
+    get _centerRadius(): number;
+    get _centerCircumference(): number;
+    get _progress(): number;
+    get _remainder(): number;
+    get _progressStrokeWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressCircleRingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressCircleRingComponent, "kirby-progress-circle-ring", never, { "radius": { "alias": "radius"; "required": false; }; "value": { "alias": "value"; "required": false; }; "themeColor": { "alias": "themeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "upperBound": { "alias": "upperBound"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { ProgressCircleComponent, ProgressCircleRingComponent };
+//# sourceMappingURL=index.d.ts.map

package/progress-circle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../progress-circle/src/progress-circle.component.ts","../../progress-circle/src/progress-circle-ring.component.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAaA,cAAA,uBAAA,YAAA,aAAA,EAAA,SAAA;AA8BI;AACA;AAvBF;;;;;;;;;;;;;;;;AAIE;;;AAMO;AACA;AAET;;;;AAaA;AASA;;AAYA;;AAgBA;AAKA;AAIA;AAIA;;;AAID;;AC7FD,cAAA,2BAAA,YAAA,aAAA;;;AASW;;;AAKT;AAEA;;;;;;;;;AAmCD;;;;"}

package/radio/index.d.ts

@@ -1,6 +1,100 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/radio" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-radio.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnInit, AfterContentInit, ElementRef, ChangeDetectorRef, Renderer2, EventEmitter, TemplateRef } from '@angular/core';
+import { IonicElementPartHelper } from '@kirbydesign/designsystem/helpers';
+import { ControlValueAccessor } from '@angular/forms';
+import { FormFieldControl } from '@kirbydesign/designsystem/types';
+import * as i3 from '@angular/common';
+import * as i4 from '@ionic/angular/standalone';
+
+declare class RadioComponent implements AfterViewInit, OnInit, AfterContentInit {
+    private element;
+    private ionicElementPartHelper;
+    private ionRadioElement?;
+    value: any;
+    text: string;
+    size: 'xs' | 'sm' | 'md';
+    disabled: boolean;
+    get _isDisabled(): string;
+    _labelText: string;
+    get buttonTabIndex(): number;
+    _justify: 'start' | 'end' | 'space-between';
+    _labelPlacement: 'end' | 'fixed' | 'stacked' | 'start';
+    _hasSlottedContent: boolean;
+    constructor(element: ElementRef<HTMLElement>, ionicElementPartHelper: IonicElementPartHelper);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "kirby-radio", never, { "value": { "alias": "value"; "required": false; }; "text": { "alias": "text"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class RadioGroupComponent implements AfterContentInit, ControlValueAccessor, FormFieldControl, AfterViewInit {
+    private changeDetectionRef;
+    private element;
+    private renderer;
+    constructor(changeDetectionRef: ChangeDetectorRef, element: ElementRef<HTMLElement>, renderer: Renderer2);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _hasError;
+    get hasError(): boolean;
+    set hasError(value: boolean);
+    hasErrorChange: EventEmitter<boolean>;
+    get items(): string[] | any[];
+    set items(value: string[] | any[]);
+    itemTextProperty: string;
+    itemDisabledProperty: string;
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    get value(): string | any;
+    set value(value: string | any);
+    private get hasValue();
+    /**
+     * Emitted when an option is selected
+     */
+    valueChange: EventEmitter<string | any>;
+    _customItemTemplate: TemplateRef<any>;
+    private _disabled;
+    private _items;
+    private _onChangeCallback;
+    private _onTouched;
+    private _selectedIndex;
+    private _value?;
+    private _attributesToForward;
+    private radioButtons;
+    private projectedRadioButtons;
+    private get hasItemsFromContentProjection();
+    focus(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    _getTextFromItem(item: string | any): string;
+    _getDisabledStateFromItem(item: string | any): boolean;
+    get _hasItems(): boolean;
+    _onChange(value: string | any): void;
+    _onRadioBlur(): void;
+    private getIndexOfSelectedValue;
+    private getIndexOfProjectedRadio;
+    private getValueFromSelectedIndex;
+    private getValueFromProjectedRadios;
+    private initSelectionStateFromProjectedContent;
+    private listenForProjectedRadiosChange;
+    private refreshSelectionState;
+    private refreshStateFromProjectedContent;
+    private setSelectedItem;
+    private setProjectedRadiosDisabledState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "kirby-radio-group", never, { "disabled": { "alias": "disabled"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "items": { "alias": "items"; "required": false; }; "itemTextProperty": { "alias": "itemTextProperty"; "required": false; }; "itemDisabledProperty": { "alias": "itemDisabledProperty"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "hasErrorChange": "hasErrorChange"; "valueChange": "valueChange"; }, ["_customItemTemplate", "projectedRadioButtons"], ["*"], false, never>;
+}
+
+declare class RadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioModule, [typeof RadioComponent, typeof RadioGroupComponent], [typeof i3.CommonModule, typeof i4.IonRadio, typeof i4.IonRadioGroup], [typeof RadioComponent, typeof RadioGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioModule>;
+}
+
+export { RadioComponent, RadioGroupComponent, RadioModule };
+//# sourceMappingURL=index.d.ts.map

package/radio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../radio/src/radio.component.ts","../../radio/src/radio-group/radio-group.component.ts","../../radio/src/radio-module.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;;;;AAeA,cAAA,cAAA,YAAA,aAAA,EAAA,MAAA,EAAA,gBAAA;AAwCI;AACA;;;;AArBF;;AAIA;;;AAWA;;;;AASA;AAiBA;AAUA;;;;AAYD;;AC1ED,cAAA,mBAAA,YAAA,gBAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,aAAA;AAkBI;AACA;AACA;AAFQ,oCAAA,iBAAA,WAAA,UAAA,CAAA,WAAA,aAAA,SAAA;;AAWV;;;AAaA;AAOU,oBAAA,YAAA;AAEV;;AAWA;AAGA;;AAMA;AAQA;AAIA;;AAQA;;AAEG;AACO,iBAAA,YAAA;AAKV,yBAAA,WAAA;;;;;;;;;;;;AAoCA;AAKA;AASA;AAIA;;AASA;AAQA;AAKA;;AASA;;AAeA;AAOA;AAYA;AAOA;AASA;AAMA;AAYA;AASA;AAMA;AAMA;;;AASD;;AC1SD,cAAA,WAAA;;;;AAK2B;;;;"}

package/range/index.d.ts

@@ -1,6 +1,45 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/range" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-range.d.ts.map
+import * as i0 from '@angular/core';
+import { OnChanges, OnInit, AfterViewInit, EventEmitter, ElementRef, Renderer2 } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class RangeComponent implements OnChanges, OnInit, ControlValueAccessor, AfterViewInit {
+    private element;
+    private renderer;
+    minLabel: string;
+    maxLabel: string;
+    debounce: number;
+    max: number;
+    min: number;
+    pin: boolean;
+    step: number;
+    ticks: boolean;
+    disabled: boolean;
+    pinFormatter: (value: number) => string | number;
+    set value(value: number);
+    get value(): number;
+    change: EventEmitter<number>;
+    move: EventEmitter<number>;
+    private ionRange;
+    private currentValue;
+    private _attributesToForward;
+    constructor(element: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    private getTicks;
+    private initializeMoveEventEmitter;
+    private defaultPinFormatter;
+    setDisabledState?(isDisabled: boolean): void;
+    _onRangeValueChange($event: any): void;
+    _onRangeKnobMove($event: any): void;
+    onTouched: () => void;
+    propagateChange: (_: any) => void;
+    writeValue(value: any): void;
+    registerOnTouched(fn: any): void;
+    registerOnChange(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RangeComponent, "kirby-range", never, { "minLabel": { "alias": "minLabel"; "required": false; }; "maxLabel": { "alias": "maxLabel"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "pin": { "alias": "pin"; "required": false; }; "step": { "alias": "step"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "pinFormatter": { "alias": "pinFormatter"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "change": "change"; "move": "move"; }, never, never, true, never>;
+}
+
+export { RangeComponent };
+//# sourceMappingURL=index.d.ts.map

package/range/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../range/src/range.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA,cAAA,cAAA,YAAA,SAAA,EAAA,MAAA,EAAA,oBAAA,EAAA,aAAA;AA8CI;AACA;;;;;;;AA1BO;;AAEA;;AAET;;AAYU,YAAA,YAAA;AACA,UAAA,YAAA;;;;;;;AAmCV;AASA;AAQA;AAUA;AAIO;AAIA;AAKA;AAKA;;AAKA;AAMA;AAIA;;;AAGR;;;;"}

package/reorder-list/index.d.ts

@@ -1,6 +1,34 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/reorder-list" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-reorder-list.d.ts.map
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, EventEmitter, TemplateRef, QueryList, ElementRef, ChangeDetectorRef } from '@angular/core';
+
+declare class ReorderEvent {
+    private origEvent;
+    private parent?;
+    constructor(ev: CustomEvent<any>, parentItem?: any);
+    complete(listOrReorder?: boolean | any[]): Promise<any>;
+    get parentItem(): any;
+}
+
+declare class ReorderListComponent implements OnChanges, OnDestroy {
+    private cdr;
+    items: any[];
+    subItemsName: string;
+    getItemTextDefault: (item: any) => string;
+    itemReorder: EventEmitter<ReorderEvent>;
+    subItemReorder: EventEmitter<ReorderEvent>;
+    itemTemplate: TemplateRef<any>;
+    reorderGroupContainer: QueryList<ElementRef>;
+    private observer;
+    reorderActive: boolean;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    private setupDomListener;
+    doReorder(ev: CustomEvent): void;
+    doSubReorder(ev: CustomEvent, parentItem: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReorderListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReorderListComponent, "kirby-reorder-list", never, { "items": { "alias": "items"; "required": false; }; "subItemsName": { "alias": "subItemsName"; "required": false; }; "getItemTextDefault": { "alias": "getItemTextDefault"; "required": false; }; }, { "itemReorder": "itemReorder"; "subItemReorder": "subItemReorder"; }, ["itemTemplate"], never, true, never>;
+}
+
+export { ReorderEvent, ReorderListComponent };
+//# sourceMappingURL=index.d.ts.map

package/reorder-list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../reorder-list/src/reorder-event.ts","../../reorder-list/src/reorder-list.component.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAAA,cAAA,YAAA;;;;AASE,+CAAA,OAAA;;AAOD;;ACMD,cAAA,oBAAA,YAAA,SAAA,EAAA,SAAA;AAsBc;;;AAbH;AAEC,iBAAA,YAAA,CAAA,YAAA;AACA,oBAAA,YAAA,CAAA,YAAA;AAGV,kBAAA,WAAA;AAEA,2BAAA,SAAA,CAAA,UAAA;;;AAKoB,qBAAA,iBAAA;AAEpB;AAQA;;AA0BA,qBAAA,WAAA;;;;AASD;;;;"}

package/router-outlet/index.d.ts

@@ -1,6 +1,20 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/router-outlet" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-router-outlet.d.ts.map
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@ionic/angular/standalone';
+export { NavController } from '@ionic/angular/standalone';
+
+declare class RouterOutletComponent {
+    main: boolean;
+    _animated: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RouterOutletComponent, "kirby-router-outlet", never, { "main": { "alias": "main"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RouterOutletModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterOutletModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RouterOutletModule, [typeof RouterOutletComponent], [typeof i2.CommonModule, typeof i3.IonRouterOutlet], [typeof RouterOutletComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RouterOutletModule>;
+}
+
+export { RouterOutletComponent, RouterOutletModule };
+//# sourceMappingURL=index.d.ts.map

package/router-outlet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../router-outlet/src/router-outlet.component.ts","../../router-outlet/src/router-outlet.module.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;AAGA,cAAA,qBAAA;;AAUE;;;AACD;;ACTD,cAAA,kBAAA;;;;AAKkC;;;;"}

package/section-header/index.d.ts

@@ -1,6 +1,9 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kirbydesign/designsystem/section-header" />
-export * from './public_api';
-//# sourceMappingURL=kirbydesign-designsystem-section-header.d.ts.map
+import * as i0 from '@angular/core';
+
+declare class SectionHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionHeaderComponent, "kirby-section-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { SectionHeaderComponent };
+//# sourceMappingURL=index.d.ts.map

package/section-header/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../section-header/src/section-header.component.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,cAAA,sBAAA;;;AAOsC;;;;"}