@baloise/ds-angular 0.0.5-nightly.e56f740

package/components/bal-textarea.d.ts

@@ -0,0 +1,24 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, NgZone } from '@angular/core';
+import type { Components } from '@baloise/ds-core';
+import { ValueAccessor } from '../generated/value-accessor';
+import * as i0 from "@angular/core";
+export declare class BalTextarea extends ValueAccessor {
+    protected z: NgZone;
+    protected el: HTMLElement;
+    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone, injector: Injector);
+    handleBalInput(event: CustomEvent<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BalTextarea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BalTextarea, "bal-textarea", never, { "autoInvalidOff": "autoInvalidOff"; "autocapitalize": "autocapitalize"; "autofocus": "autofocus"; "clickable": "clickable"; "cols": "cols"; "debounce": "debounce"; "disabled": "disabled"; "inputmode": "inputmode"; "invalid": "invalid"; "maxLength": "maxLength"; "minLength": "minLength"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "rows": "rows"; "value": "value"; "wrap": "wrap"; }, { "balChange": "balChange"; "balInput": "balInput"; "balBlur": "balBlur"; "balKeyPress": "balKeyPress"; "balFocus": "balFocus"; }, never, ["*"], true, never>;
+}
+export declare interface BalTextarea extends Components.BalTextarea {
+    /** Emitted when the input value has changed.. */
+    balChange: EventEmitter<BalEvents.BalTextareaCustomEvent<string | undefined>>;
+    /** Emitted when a keyboard input occurred. */
+    balInput: EventEmitter<BalEvents.BalTextareaCustomEvent<string | undefined>>;
+    /** Emitted when a keyboard input occurred. */
+    balBlur: EventEmitter<BalEvents.BalTextareaCustomEvent<FocusEvent>>;
+    /** Emitted when a keyboard key has pressed. */
+    balKeyPress: EventEmitter<BalEvents.BalTextareaCustomEvent<KeyboardEvent>>;
+    /** Emitted when the input has focus. */
+    balFocus: EventEmitter<BalEvents.BalTextareaCustomEvent<FocusEvent>>;
+}

package/components/bal-time-input.d.ts

@@ -0,0 +1,26 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, NgZone } from '@angular/core';
+import type { Components } from '@baloise/ds-core';
+import { ValueAccessor } from '../generated/value-accessor';
+import * as i0 from "@angular/core";
+export declare class BalTimeInput extends ValueAccessor {
+    protected z: NgZone;
+    protected el: HTMLElement;
+    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone, injector: Injector);
+    handleBalInput(event: CustomEvent<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BalTimeInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BalTimeInput, "bal-time-input", never, { "autoInvalidOff": "autoInvalidOff"; "debounce": "debounce"; "disabled": "disabled"; "invalid": "invalid"; "name": "name"; "readonly": "readonly"; "required": "required"; "value": "value"; }, { "balInput": "balInput"; "balChange": "balChange"; "balBlur": "balBlur"; "balFocus": "balFocus"; "balKeyPress": "balKeyPress"; "balClick": "balClick"; }, never, ["*"], true, never>;
+}
+export declare interface BalTimeInput extends Components.BalTimeInput {
+    /** Emitted when a keyboard input occurred. */
+    balInput: EventEmitter<BalEvents.BalTimeInputCustomEvent<string | undefined>>;
+    /** Emitted when the value has changed. */
+    balChange: EventEmitter<BalEvents.BalTimeInputCustomEvent<string | undefined>>;
+    /** Emitted when the input loses focus. */
+    balBlur: EventEmitter<BalEvents.BalTimeInputCustomEvent<FocusEvent>>;
+    /** Emitted when the input has focus. */
+    balFocus: EventEmitter<BalEvents.BalTimeInputCustomEvent<FocusEvent>>;
+    /** Emitted when a keyboard key has pressed. */
+    balKeyPress: EventEmitter<BalEvents.BalTimeInputCustomEvent<KeyboardEvent>>;
+    /** Emitted when the input has clicked. */
+    balClick: EventEmitter<BalEvents.BalTimeInputCustomEvent<MouseEvent>>;
+}

package/components/index.d.ts

@@ -0,0 +1,14 @@
+export * from './bal-checkbox';
+export * from './bal-checkbox-group';
+export * from './bal-date';
+export * from './bal-datepicker';
+export * from './bal-file-upload';
+export * from './bal-input-date';
+export * from './bal-input-slider';
+export * from './bal-input-stepper';
+export * from './bal-input';
+export * from './bal-number-input';
+export * from './bal-radio-group';
+export * from './bal-select';
+export * from './bal-textarea';
+export * from './bal-time-input';

package/directives/error.component.d.ts

@@ -0,0 +1,8 @@
+import { ChangeDetectorRef, Injector } from '@angular/core';
+import { BalNgErrorComponent as BalNgErrorComponentBase } from '@baloise/ds-angular-common';
+import * as i0 from "@angular/core";
+export declare class BalNgErrorComponent extends BalNgErrorComponentBase {
+    constructor(injector: Injector, cd: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BalNgErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BalNgErrorComponent, "bal-ng-error", never, {}, {}, never, ["*"], true, never>;
+}

package/directives/focus.directive.d.ts

@@ -0,0 +1,6 @@
+import { BalAutoFocus as BalAutoFocusBase } from '@baloise/ds-angular-common';
+import * as i0 from "@angular/core";
+export declare class BalAutoFocus extends BalAutoFocusBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BalAutoFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BalAutoFocus, "[balAutoFocus]", never, {}, {}, never, never, false, never>;
+}

package/esm2020/app-initialize.mjs

@@ -0,0 +1,28 @@
+import { initializeBaloiseDesignSystem } from '@baloise/ds-core/components';
+import { raf } from '@baloise/ds-angular-common';
+export const appInitialize = (config, doc, zone) => {
+    return async () => {
+        const win = doc.defaultView;
+        if (win && typeof window !== 'undefined') {
+            const aelFn = '__zone_symbol__addEventListener' in doc.body ? '__zone_symbol__addEventListener' : 'addEventListener';
+            const platformConfig = {
+                raf,
+                jmp: (h) => zone.runOutsideAngular(h),
+                ael(elm, eventName, cb, opts) {
+                    if (elm && elm[aelFn]) {
+                        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                        ;
+                        elm[aelFn](eventName, cb, opts);
+                    }
+                },
+                rel(elm, eventName, cb, opts) {
+                    if (elm) {
+                        elm.removeEventListener(eventName, cb, opts);
+                    }
+                },
+            };
+            initializeBaloiseDesignSystem(config.defaults, platformConfig, win);
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/baloise-ds-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFsb2lzZS1kcy1hbmd1bGFyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JhbG9pc2UtZHMtYW5ndWxhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/bundles.mjs

@@ -0,0 +1,167 @@
+import { BalCheckbox, BalCheckboxGroup, BalDate, BalDatepicker, BalInput, BalInputDate, BalInputSlider, BalInputStepper, BalNumberInput, BalRadioGroup, BalSelect, BalTextarea, BalTimeInput, } from './components';
+import { BalNgErrorComponent } from './directives/error.component';
+import { BalAccordion, BalAccordionDetails, BalAccordionSummary, BalAccordionTrigger, BalApp, BalButton, BalButtonGroup, BalCard, BalCardActions, BalCardButton, BalCardContent, BalCardSubtitle, BalCardTitle, BalCarousel, BalCarouselItem, BalCheckboxButton, BalContent, BalData, BalDataItem, BalDataLabel, BalDataValue, BalDivider, BalField, BalFieldControl, BalFieldHint, BalFieldLabel, BalFieldMessage, BalFooter, BalForm, BalFormCol, BalFormGrid, BalHeading, BalHint, BalHintText, BalHintTitle, BalInputGroup, BalLabel, BalList, BalListItem, BalListItemAccordionBody, BalListItemAccordionHead, BalListItemContent, BalListItemIcon, BalListItemSubtitle, BalListItemTitle, BalLogo, BalModal, BalModalBody, BalModalHeader, BalNavbar, BalNavbarBrand, BalNavbarMenu, BalNavbarMenuEnd, BalNavbarMenuStart, BalRadio, BalRadioButton, BalSelectOption, BalShape, BalStack, BalStage, BalStageBackLink, BalStageBody, BalStageFoot, BalStageHead, BalStageImage, BalStepItem, BalSteps, BalTabItem, BalTabs, BalTag, BalTagGroup, BalText, } from './generated/proxies';
+export const BalAccordionBundle = [BalAccordion, BalAccordionDetails, BalAccordionSummary, BalAccordionTrigger];
+export const BalButtonBundle = [BalButton, BalButtonGroup];
+export const BalCardBundle = [
+    BalCard,
+    BalCardContent,
+    BalCardTitle,
+    BalCardActions,
+    BalCardSubtitle,
+    BalCardButton,
+];
+export const BalDataBundle = [BalData, BalDataItem, BalDataLabel, BalDataValue];
+export const BalHintBundle = [BalHint, BalHintText, BalHintTitle];
+export const BalCarouselBundle = [BalCarousel, BalCarouselItem];
+export const BalListBundle = [
+    BalList,
+    BalListItem,
+    BalListItemAccordionHead,
+    BalListItemAccordionBody,
+    BalListItemContent,
+    BalListItemIcon,
+    BalListItemTitle,
+    BalListItemSubtitle,
+];
+export const BalNavbarBundle = [BalNavbar, BalNavbarBrand, BalNavbarMenu, BalNavbarMenuStart, BalNavbarMenuEnd];
+export const BalStageBundle = [
+    BalStage,
+    BalStageBackLink,
+    BalStageBody,
+    BalStageFoot,
+    BalStageHead,
+    BalStageImage,
+];
+export const BalTagBundle = [BalTag, BalTagGroup];
+export const BalTabsBundle = [BalTabs, BalTabItem];
+export const BalStepsBundle = [BalSteps, BalStepItem];
+export const BalModalBundle = [BalModal, BalModalBody, BalModalHeader];
+export const BalSelectBundle = [BalSelectOption, BalSelect];
+export const BalCheckboxBundle = [BalCheckbox, BalCheckboxGroup, BalCheckboxButton];
+export const BalRadioBundle = [BalRadio, BalRadioButton, BalRadioGroup];
+export const BalFormGridBundle = [BalFormGrid, BalFormCol];
+export const BalFieldBundle = [
+    BalField,
+    BalFieldLabel,
+    BalFieldControl,
+    BalFieldMessage,
+    BalFieldControl,
+    BalFieldHint,
+];
+/* Component Sections */
+export const BalFormBundle = [
+    //
+    // Form Layout
+    BalForm,
+    BalInputGroup,
+    ...BalFieldBundle,
+    ...BalButtonBundle,
+    ...BalFormGridBundle,
+    BalNgErrorComponent,
+    //
+    // Form Controls
+    ...BalCheckboxBundle,
+    BalDate,
+    BalDatepicker,
+    BalInputDate,
+    BalInputStepper,
+    BalInputSlider,
+    BalInput,
+    BalNumberInput,
+    ...BalRadioBundle,
+    ...BalSelectBundle,
+    BalTextarea,
+    BalTimeInput,
+];
+export const BalLayoutBundle = [BalStack, BalContent, BalLogo, BalShape, BalApp, BalDivider, BalFooter];
+export const BalTypographyBundle = [BalHeading, BalText, BalLabel];
+export const BalComponentBundle = [
+    BalAccordion,
+    BalAccordionDetails,
+    BalAccordionSummary,
+    BalAccordionTrigger,
+    BalApp,
+    BalButton,
+    BalButtonGroup,
+    BalCard,
+    BalCardActions,
+    BalCardButton,
+    BalCardContent,
+    BalCardSubtitle,
+    BalCardTitle,
+    BalCarousel,
+    BalCarouselItem,
+    BalCheckboxButton,
+    BalContent,
+    BalData,
+    BalDataItem,
+    BalDataLabel,
+    BalDataValue,
+    BalDivider,
+    BalField,
+    BalFieldControl,
+    BalFieldHint,
+    BalFieldLabel,
+    BalFieldMessage,
+    BalFooter,
+    BalForm,
+    BalFormCol,
+    BalFormGrid,
+    BalHeading,
+    BalHint,
+    BalHintText,
+    BalHintTitle,
+    BalInputGroup,
+    BalLabel,
+    BalList,
+    BalListItem,
+    BalListItemAccordionBody,
+    BalListItemAccordionHead,
+    BalListItemContent,
+    BalListItemIcon,
+    BalListItemSubtitle,
+    BalListItemTitle,
+    BalLogo,
+    BalModal,
+    BalModalBody,
+    BalModalHeader,
+    BalNavbar,
+    BalNavbarBrand,
+    BalNavbarMenu,
+    BalNavbarMenuEnd,
+    BalNavbarMenuStart,
+    BalRadio,
+    BalRadioButton,
+    BalSelectOption,
+    BalShape,
+    BalStack,
+    BalStage,
+    BalStageBackLink,
+    BalStageBody,
+    BalStageFoot,
+    BalStageHead,
+    BalStageImage,
+    BalStepItem,
+    BalSteps,
+    BalTabItem,
+    BalTabs,
+    BalTag,
+    BalTagGroup,
+    BalText,
+    BalNgErrorComponent,
+    BalCheckbox,
+    BalCheckboxGroup,
+    BalDate,
+    BalDatepicker,
+    BalInput,
+    BalInputDate,
+    BalInputSlider,
+    BalInputStepper,
+    BalNumberInput,
+    BalRadioGroup,
+    BalSelect,
+    BalTextarea,
+    BalTimeInput,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundles.js","sourceRoot":"","sources":["../../src/bundles.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BalCheckbox,\n  BalCheckboxGroup,\n  BalDate,\n  BalDatepicker,\n  BalInput,\n  BalInputDate,\n  BalInputSlider,\n  BalInputStepper,\n  BalNumberInput,\n  BalRadioGroup,\n  BalSelect,\n  BalTextarea,\n  BalTimeInput,\n} from './components'\nimport { BalNgErrorComponent } from './directives/error.component'\nimport {\n  BalAccordion,\n  BalAccordionDetails,\n  BalAccordionSummary,\n  BalAccordionTrigger,\n  BalApp,\n  BalButton,\n  BalButtonGroup,\n  BalCard,\n  BalCardActions,\n  BalCardButton,\n  BalCardContent,\n  BalCardSubtitle,\n  BalCardTitle,\n  BalCarousel,\n  BalCarouselItem,\n  BalCheckboxButton,\n  BalContent,\n  BalData,\n  BalDataItem,\n  BalDataLabel,\n  BalDataValue,\n  BalDivider,\n  BalField,\n  BalFieldControl,\n  BalFieldHint,\n  BalFieldLabel,\n  BalFieldMessage,\n  BalFooter,\n  BalForm,\n  BalFormCol,\n  BalFormGrid,\n  BalHeading,\n  BalHint,\n  BalHintText,\n  BalHintTitle,\n  BalInputGroup,\n  BalLabel,\n  BalList,\n  BalListItem,\n  BalListItemAccordionBody,\n  BalListItemAccordionHead,\n  BalListItemContent,\n  BalListItemIcon,\n  BalListItemSubtitle,\n  BalListItemTitle,\n  BalLogo,\n  BalModal,\n  BalModalBody,\n  BalModalHeader,\n  BalNavbar,\n  BalNavbarBrand,\n  BalNavbarMenu,\n  BalNavbarMenuEnd,\n  BalNavbarMenuStart,\n  BalRadio,\n  BalRadioButton,\n  BalSelectOption,\n  BalShape,\n  BalStack,\n  BalStage,\n  BalStageBackLink,\n  BalStageBody,\n  BalStageFoot,\n  BalStageHead,\n  BalStageImage,\n  BalStepItem,\n  BalSteps,\n  BalTabItem,\n  BalTabs,\n  BalTag,\n  BalTagGroup,\n  BalText,\n} from './generated/proxies'\n\nexport const BalAccordionBundle = [BalAccordion, BalAccordionDetails, BalAccordionSummary, BalAccordionTrigger] as const\n\nexport const BalButtonBundle = [BalButton, BalButtonGroup] as const\n\nexport const BalCardBundle = [\n  BalCard,\n  BalCardContent,\n  BalCardTitle,\n  BalCardActions,\n  BalCardSubtitle,\n  BalCardButton,\n] as const\n\nexport const BalDataBundle = [BalData, BalDataItem, BalDataLabel, BalDataValue] as const\n\nexport const BalHintBundle = [BalHint, BalHintText, BalHintTitle] as const\n\nexport const BalCarouselBundle = [BalCarousel, BalCarouselItem] as const\n\nexport const BalListBundle = [\n  BalList,\n  BalListItem,\n  BalListItemAccordionHead,\n  BalListItemAccordionBody,\n  BalListItemContent,\n  BalListItemIcon,\n  BalListItemTitle,\n  BalListItemSubtitle,\n] as const\n\nexport const BalNavbarBundle = [BalNavbar, BalNavbarBrand, BalNavbarMenu, BalNavbarMenuStart, BalNavbarMenuEnd] as const\n\nexport const BalStageBundle = [\n  BalStage,\n  BalStageBackLink,\n  BalStageBody,\n  BalStageFoot,\n  BalStageHead,\n  BalStageImage,\n] as const\n\nexport const BalTagBundle = [BalTag, BalTagGroup] as const\n\nexport const BalTabsBundle = [BalTabs, BalTabItem] as const\n\nexport const BalStepsBundle = [BalSteps, BalStepItem] as const\n\nexport const BalModalBundle = [BalModal, BalModalBody, BalModalHeader] as const\n\nexport const BalSelectBundle = [BalSelectOption, BalSelect] as const\n\nexport const BalCheckboxBundle = [BalCheckbox, BalCheckboxGroup, BalCheckboxButton] as const\n\nexport const BalRadioBundle = [BalRadio, BalRadioButton, BalRadioGroup] as const\n\nexport const BalFormGridBundle = [BalFormGrid, BalFormCol] as const\n\nexport const BalFieldBundle = [\n  BalField,\n  BalFieldLabel,\n  BalFieldControl,\n  BalFieldMessage,\n  BalFieldControl,\n  BalFieldHint,\n] as const\n\n/* Component Sections */\n\nexport const BalFormBundle = [\n  //\n  // Form Layout\n  BalForm,\n  BalInputGroup,\n  ...BalFieldBundle,\n  ...BalButtonBundle,\n  ...BalFormGridBundle,\n  BalNgErrorComponent,\n  //\n  // Form Controls\n  ...BalCheckboxBundle,\n  BalDate,\n  BalDatepicker,\n  BalInputDate,\n  BalInputStepper,\n  BalInputSlider,\n  BalInput,\n  BalNumberInput,\n  ...BalRadioBundle,\n  ...BalSelectBundle,\n  BalTextarea,\n  BalTimeInput,\n] as const\n\nexport const BalLayoutBundle = [BalStack, BalContent, BalLogo, BalShape, BalApp, BalDivider, BalFooter] as const\n\nexport const BalTypographyBundle = [BalHeading, BalText, BalLabel] as const\n\nexport const BalComponentBundle = [\n  BalAccordion,\n  BalAccordionDetails,\n  BalAccordionSummary,\n  BalAccordionTrigger,\n  BalApp,\n  BalButton,\n  BalButtonGroup,\n  BalCard,\n  BalCardActions,\n  BalCardButton,\n  BalCardContent,\n  BalCardSubtitle,\n  BalCardTitle,\n  BalCarousel,\n  BalCarouselItem,\n  BalCheckboxButton,\n  BalContent,\n  BalData,\n  BalDataItem,\n  BalDataLabel,\n  BalDataValue,\n  BalDivider,\n  BalField,\n  BalFieldControl,\n  BalFieldHint,\n  BalFieldLabel,\n  BalFieldMessage,\n  BalFooter,\n  BalForm,\n  BalFormCol,\n  BalFormGrid,\n  BalHeading,\n  BalHint,\n  BalHintText,\n  BalHintTitle,\n  BalInputGroup,\n  BalLabel,\n  BalList,\n  BalListItem,\n  BalListItemAccordionBody,\n  BalListItemAccordionHead,\n  BalListItemContent,\n  BalListItemIcon,\n  BalListItemSubtitle,\n  BalListItemTitle,\n  BalLogo,\n  BalModal,\n  BalModalBody,\n  BalModalHeader,\n  BalNavbar,\n  BalNavbarBrand,\n  BalNavbarMenu,\n  BalNavbarMenuEnd,\n  BalNavbarMenuStart,\n  BalRadio,\n  BalRadioButton,\n  BalSelectOption,\n  BalShape,\n  BalStack,\n  BalStage,\n  BalStageBackLink,\n  BalStageBody,\n  BalStageFoot,\n  BalStageHead,\n  BalStageImage,\n  BalStepItem,\n  BalSteps,\n  BalTabItem,\n  BalTabs,\n  BalTag,\n  BalTagGroup,\n  BalText,\n  BalNgErrorComponent,\n  BalCheckbox,\n  BalCheckboxGroup,\n  BalDate,\n  BalDatepicker,\n  BalInput,\n  BalInputDate,\n  BalInputSlider,\n  BalInputStepper,\n  BalNumberInput,\n  BalRadioGroup,\n  BalSelect,\n  BalTextarea,\n  BalTimeInput,\n] as const\n"]}

package/esm2020/components/bal-checkbox-group.mjs

@@ -0,0 +1,55 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostListener, Injector, NgZone, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { defineCustomElement } from '@baloise/ds-core/components/bal-checkbox-group';
+import { ProxyCmp, proxyOutputs } from '../generated/angular-component-lib/utils';
+import { ValueAccessor } from '../generated/value-accessor';
+import { BalCheckboxGroupInputs, BalCheckboxGroupMethods, BalCheckboxGroupOutputs } from '../generated/meta';
+import * as i0 from "@angular/core";
+const accessorProvider = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => BalCheckboxGroup),
+    multi: true,
+};
+let BalCheckboxGroup = class BalCheckboxGroup extends ValueAccessor {
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, BalCheckboxGroupOutputs);
+    }
+    handleBalChange(event) {
+        this.handleValueChange(event);
+    }
+};
+BalCheckboxGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalCheckboxGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BalCheckboxGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: BalCheckboxGroup, isStandalone: true, selector: "bal-checkbox-group", inputs: { autoInvalidOff: "autoInvalidOff", columns: "columns", columnsMobile: "columnsMobile", columnsTablet: "columnsTablet", control: "control", disabled: "disabled", expanded: "expanded", interface: "interface", invalid: "invalid", name: "name", options: "options", readonly: "readonly", value: "value", vertical: "vertical", verticalOnMobile: "verticalOnMobile" }, outputs: { balChange: "balChange", balFocus: "balFocus", balBlur: "balBlur" }, host: { listeners: { "balChange": "handleBalChange($event)" } }, providers: [accessorProvider], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+BalCheckboxGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement,
+        inputs: BalCheckboxGroupInputs,
+        methods: BalCheckboxGroupMethods,
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone,
+        Injector])
+], BalCheckboxGroup);
+export { BalCheckboxGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalCheckboxGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bal-checkbox-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    providers: [accessorProvider],
+                    standalone: true,
+                    inputs: BalCheckboxGroupInputs,
+                    outputs: BalCheckboxGroupOutputs,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleBalChange: [{
+                type: HostListener,
+                args: ['balChange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/bal-checkbox.mjs

@@ -0,0 +1,59 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostListener, Injector, NgZone, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { defineCustomElement } from '@baloise/ds-core/components/bal-checkbox';
+import { ProxyCmp, proxyOutputs } from '../generated/angular-component-lib/utils';
+import { ValueAccessor } from '../generated/value-accessor';
+import { BalCheckboxInputs, BalCheckboxMethods, BalCheckboxOutputs } from '../generated/meta';
+import * as i0 from "@angular/core";
+const accessorProvider = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => BalCheckbox),
+    multi: true,
+};
+let BalCheckbox = class BalCheckbox extends ValueAccessor {
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, BalCheckboxOutputs);
+    }
+    handleBalChange(event) {
+        this.handleValueChange(event);
+    }
+    writeValue(value) {
+        this.elementRef.nativeElement.checked = this.lastValue = value == null ? false : value;
+        this.onStatusChange();
+    }
+};
+BalCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BalCheckbox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: BalCheckbox, isStandalone: true, selector: "bal-checkbox", inputs: { autoInvalidOff: "autoInvalidOff", checked: "checked", disabled: "disabled", flat: "flat", inline: "inline", interface: "interface", invalid: "invalid", invisible: "invisible", label: "label", labelHidden: "labelHidden", name: "name", nonSubmit: "nonSubmit", readonly: "readonly", required: "required", value: "value" }, outputs: { balFocus: "balFocus", balBlur: "balBlur", balChange: "balChange" }, host: { listeners: { "balChange": "handleBalChange($event)" } }, providers: [accessorProvider], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+BalCheckbox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement,
+        inputs: BalCheckboxInputs,
+        methods: BalCheckboxMethods,
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone,
+        Injector])
+], BalCheckbox);
+export { BalCheckbox };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bal-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    providers: [accessorProvider],
+                    standalone: true,
+                    inputs: BalCheckboxInputs,
+                    outputs: BalCheckboxOutputs,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleBalChange: [{
+                type: HostListener,
+                args: ['balChange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/bal-date.mjs

@@ -0,0 +1,55 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostListener, Injector, NgZone, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { defineCustomElement } from '@baloise/ds-core/components/bal-date';
+import { ProxyCmp, proxyOutputs } from '../generated/angular-component-lib/utils';
+import { ValueAccessor } from '../generated/value-accessor';
+import { BalDateInputs, BalDateMethods, BalDateOutputs } from '../generated/meta';
+import * as i0 from "@angular/core";
+const accessorProvider = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => BalDate),
+    multi: true,
+};
+let BalDate = class BalDate extends ValueAccessor {
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, BalDateOutputs);
+    }
+    handleBalChange(event) {
+        this.handleValueChange(event);
+    }
+};
+BalDate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalDate, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BalDate.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: BalDate, isStandalone: true, selector: "bal-date", inputs: { allowedDates: "allowedDates", autoInvalidOff: "autoInvalidOff", closeOnSelect: "closeOnSelect", debounce: "debounce", defaultDate: "defaultDate", disabled: "disabled", freeSolo: "freeSolo", invalid: "invalid", max: "max", maxYearProp: "maxYearProp", min: "min", minYearProp: "minYearProp", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", triggerIcon: "triggerIcon", value: "value" }, outputs: { balInput: "balInput", balChange: "balChange", balWillAnimate: "balWillAnimate", balDidAnimate: "balDidAnimate", balBlur: "balBlur", balFocus: "balFocus", balInputClick: "balInputClick", balIconClick: "balIconClick" }, host: { listeners: { "balChange": "handleBalChange($event)" } }, providers: [accessorProvider], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+BalDate = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement,
+        inputs: BalDateInputs,
+        methods: BalDateMethods,
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone,
+        Injector])
+], BalDate);
+export { BalDate };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalDate, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bal-date',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    providers: [accessorProvider],
+                    standalone: true,
+                    inputs: BalDateInputs,
+                    outputs: BalDateOutputs,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleBalChange: [{
+                type: HostListener,
+                args: ['balChange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/bal-datepicker.mjs

@@ -0,0 +1,55 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostListener, Injector, NgZone, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { defineCustomElement } from '@baloise/ds-core/components/bal-datepicker';
+import { ProxyCmp, proxyOutputs } from '../generated/angular-component-lib/utils';
+import { ValueAccessor } from '../generated/value-accessor';
+import { BalDatepickerInputs, BalDatepickerMethods, BalDatepickerOutputs } from '../generated/meta';
+import * as i0 from "@angular/core";
+const accessorProvider = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => BalDatepicker),
+    multi: true,
+};
+let BalDatepicker = class BalDatepicker extends ValueAccessor {
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, BalDatepickerOutputs);
+    }
+    handleBalChange(event) {
+        this.handleValueChange(event);
+    }
+};
+BalDatepicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalDatepicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BalDatepicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: BalDatepicker, isStandalone: true, selector: "bal-datepicker", inputs: { allowedDates: "allowedDates", autoInvalidOff: "autoInvalidOff", closeOnSelect: "closeOnSelect", debounce: "debounce", defaultDate: "defaultDate", disabled: "disabled", invalid: "invalid", loading: "loading", max: "max", maxYearProp: "maxYearProp", min: "min", minYearProp: "minYearProp", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", triggerIcon: "triggerIcon", value: "value" }, outputs: { balChange: "balChange", balInput: "balInput", balBlur: "balBlur", balFocus: "balFocus", balInputClick: "balInputClick", balIconClick: "balIconClick" }, host: { listeners: { "balChange": "handleBalChange($event)" } }, providers: [accessorProvider], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+BalDatepicker = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement,
+        inputs: BalDatepickerInputs,
+        methods: BalDatepickerMethods,
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone,
+        Injector])
+], BalDatepicker);
+export { BalDatepicker };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: BalDatepicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bal-datepicker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    providers: [accessorProvider],
+                    standalone: true,
+                    inputs: BalDatepickerInputs,
+                    outputs: BalDatepickerOutputs,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleBalChange: [{
+                type: HostListener,
+                args: ['balChange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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