@breadstone/mosaik-elements-angular 0.0.75 → 0.0.77

package/esm2022/Controls/Components/Inputs/Calendar/CalendarComponent.mjs

@@ -0,0 +1,508 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { CalendarElement, calendarElementValueAccessor } from '@breadstone/mosaik-elements-foundation';
+import { applyDefaults, ProxyCmp } from '../../../../Utils/Proxy';
+import { FORM_STATUS_HOST, FormStatusDirective } from '../../../../Cdk/Forms/FormStatusDirective';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../Cdk/Forms/FormStatusDirective";
+/**
+ * @public
+ *
+ * Injection token for the default properties of the CalendarComponent.
+ * Use this token to provide default properties for the CalendarComponent.
+ * The properties will be applied to the component when it is created.
+ * This is useful for setting default values for properties that are not set by the user.
+ */
+export const CALENDAR_DEFAULT_PROPS = new InjectionToken('MOSAIK_CALENDAR_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ * @slot footer - The footer slot.
+ */
+let CalendarComponent = class CalendarComponent {
+    _element;
+    _zone;
+    _accessor;
+    _dateChanged;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        this._accessor = calendarElementValueAccessor(this._element);
+        this._element.addController(this._accessor);
+        this._dateChanged = new EventEmitter();
+        this._element.on('dateChanged', (e) => this.onEmit(this._dateChanged, e));
+        this._connected = new EventEmitter();
+        this._element.on('connected', (e) => this.onEmit(this._connected, e));
+        this._disconnected = new EventEmitter();
+        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));
+        this._changed = new EventEmitter();
+        this._element.on('changed', (e) => this.onEmit(this._changed, e));
+        applyDefaults(this._element, inject(CALENDAR_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get intl() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.intl;
+    }
+    set intl(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.intl = value;
+        });
+    }
+    get displayDate() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.displayDate;
+    }
+    set displayDate(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.displayDate = value;
+        });
+    }
+    get displayDateStart() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.displayDateStart;
+    }
+    set displayDateStart(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.displayDateStart = value;
+        });
+    }
+    get displayDateEnd() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.displayDateEnd;
+    }
+    set displayDateEnd(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.displayDateEnd = value;
+        });
+    }
+    get header() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.header;
+    }
+    set header(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.header = value;
+        });
+    }
+    get values() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.values;
+    }
+    set values(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.values = value;
+        });
+    }
+    get view() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.view;
+    }
+    set view(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.view = value;
+        });
+    }
+    get selectionMode() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.selectionMode;
+    }
+    set selectionMode(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.selectionMode = value;
+        });
+    }
+    get blackoutDates() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.blackoutDates;
+    }
+    set blackoutDates(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.blackoutDates = value;
+        });
+    }
+    get specialDates() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.specialDates;
+    }
+    set specialDates(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.specialDates = value;
+        });
+    }
+    get minDate() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.minDate;
+    }
+    set minDate(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.minDate = value;
+        });
+    }
+    get maxDate() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.maxDate;
+    }
+    set maxDate(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.maxDate = value;
+        });
+    }
+    get firstDayOfWeek() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.firstDayOfWeek;
+    }
+    set firstDayOfWeek(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.firstDayOfWeek = value;
+        });
+    }
+    get isTodayHighlighted() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isTodayHighlighted;
+    }
+    set isTodayHighlighted(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isTodayHighlighted = value;
+        });
+    }
+    get isWeekendHighlighted() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isWeekendHighlighted;
+    }
+    set isWeekendHighlighted(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isWeekendHighlighted = value;
+        });
+    }
+    get showWeekNumbers() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.showWeekNumbers;
+    }
+    set showWeekNumbers(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.showWeekNumbers = value;
+        });
+    }
+    get showAdjacent() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.showAdjacent;
+    }
+    set showAdjacent(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.showAdjacent = value;
+        });
+    }
+    get markerHandler() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.markerHandler;
+    }
+    set markerHandler(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.markerHandler = value;
+        });
+    }
+    get themeName() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.themeName;
+    }
+    set themeName(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.themeName = value;
+        });
+    }
+    get locale() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.locale;
+    }
+    set locale(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.locale = value;
+        });
+    }
+    get appearance() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.appearance;
+    }
+    set appearance(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.appearance = value;
+        });
+    }
+    get disabled() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.disabled;
+    }
+    set disabled(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.disabled = value;
+        });
+    }
+    get invalid() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.invalid;
+    }
+    set invalid(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.invalid = value;
+        });
+    }
+    get value() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.value;
+    }
+    set value(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.value = value;
+        });
+    }
+    get orientation() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.orientation;
+    }
+    set orientation(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.orientation = value;
+        });
+    }
+    get variant() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.variant;
+    }
+    set variant(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.variant = value;
+        });
+    }
+    get fit() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.fit;
+    }
+    set fit(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.fit = value;
+        });
+    }
+    get dir() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.dir;
+    }
+    set dir(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.dir = value;
+        });
+    }
+    get lang() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.lang;
+    }
+    set lang(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.lang = value;
+        });
+    }
+    get dateChanged() {
+        return this._dateChanged;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get disconnected() {
+        return this._disconnected;
+    }
+    get changed() {
+        return this._changed;
+    }
+    writeValue(obj) {
+        this._accessor.writeValue(obj);
+    }
+    registerOnChange(fn) {
+        this._accessor.registerOnChange(fn);
+    }
+    registerOnTouched(fn) {
+        this._accessor.registerOnTouched(fn);
+    }
+    setDisabledState(isDisabled) {
+        this._accessor.setDisabled?.(isDisabled);
+    }
+    invoke(method, ...args) {
+        return this._element[method](...args);
+    }
+    onEmit(emitter, event) {
+        if (event instanceof CustomEvent) {
+            emitter.emit(event.detail);
+        }
+        else {
+            emitter.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: CalendarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: CalendarComponent, isStandalone: true, selector: "mosaik-calendar", inputs: { intl: "intl", displayDate: "displayDate", displayDateStart: "displayDateStart", displayDateEnd: "displayDateEnd", header: "header", values: "values", view: "view", selectionMode: "selectionMode", blackoutDates: "blackoutDates", specialDates: "specialDates", minDate: "minDate", maxDate: "maxDate", firstDayOfWeek: "firstDayOfWeek", isTodayHighlighted: "isTodayHighlighted", isWeekendHighlighted: "isWeekendHighlighted", showWeekNumbers: "showWeekNumbers", showAdjacent: "showAdjacent", markerHandler: "markerHandler", themeName: "themeName", locale: "locale", appearance: "appearance", disabled: "disabled", invalid: "invalid", value: "value", orientation: "orientation", variant: "variant", fit: "fit", dir: "dir", lang: "lang" }, outputs: { dateChanged: "dateChanged", connected: "connected", disconnected: "disconnected", changed: "changed" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => CalendarComponent),
+                multi: true
+            },
+            {
+                provide: FORM_STATUS_HOST,
+                useExisting: forwardRef(() => CalendarComponent)
+            }
+        ], hostDirectives: [{ directive: i1.FormStatusDirective }], ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CalendarComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-calendar', CalendarElement),
+        inputs: ['intl', 'displayDate', 'displayDateStart', 'displayDateEnd', 'header', 'values', 'view', 'selectionMode', 'blackoutDates', 'specialDates', 'minDate', 'maxDate', 'firstDayOfWeek', 'isTodayHighlighted', 'isWeekendHighlighted', 'showWeekNumbers', 'showAdjacent', 'markerHandler', 'themeName', 'locale', 'appearance', 'disabled', 'invalid', 'value', 'orientation', 'variant', 'fit', 'dir', 'lang'],
+        methods: ['reset', 'checkValidity', 'navigatePrevious', 'navigateNext', 'navigateToday', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], CalendarComponent);
+export { CalendarComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: CalendarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-calendar',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['intl', 'displayDate', 'displayDateStart', 'displayDateEnd', 'header', 'values', 'view', 'selectionMode', 'blackoutDates', 'specialDates', 'minDate', 'maxDate', 'firstDayOfWeek', 'isTodayHighlighted', 'isWeekendHighlighted', 'showWeekNumbers', 'showAdjacent', 'markerHandler', 'themeName', 'locale', 'appearance', 'disabled', 'invalid', 'value', 'orientation', 'variant', 'fit', 'dir', 'lang'],
+                    outputs: ['dateChanged', 'connected', 'disconnected', 'changed'],
+                    hostDirectives: [FormStatusDirective],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => CalendarComponent),
+                            multi: true
+                        },
+                        {
+                            provide: FORM_STATUS_HOST,
+                            useExisting: forwardRef(() => CalendarComponent)
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [], propDecorators: { intl: [{
+                type: Input
+            }], displayDate: [{
+                type: Input
+            }], displayDateStart: [{
+                type: Input
+            }], displayDateEnd: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], view: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], blackoutDates: [{
+                type: Input
+            }], specialDates: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], firstDayOfWeek: [{
+                type: Input
+            }], isTodayHighlighted: [{
+                type: Input
+            }], isWeekendHighlighted: [{
+                type: Input
+            }], showWeekNumbers: [{
+                type: Input
+            }], showAdjacent: [{
+                type: Input
+            }], markerHandler: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], fit: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], dateChanged: [{
+                type: Output
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideCalendar(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: CALENDAR_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CalendarComponent.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Inputs/Calendar/CalendarComponent.ts"],"names":[],"mappings":"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","sourcesContent":["// ------------------------------------------------------------------------------\n// <auto-generated>\n//     This code was generated by a tool.\n//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n// </auto-generated>\n// ------------------------------------------------------------------------------\n\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EnvironmentProviders, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { CalendarElement, IElementValueAccessor, calendarElementValueAccessor } from '@breadstone/mosaik-elements-foundation';\nimport { applyDefaults, ProxyCmp, MethodMap } from '../../../../Utils/Proxy';\nimport { FORM_STATUS_HOST, FormStatusDirective } from '../../../../Cdk/Forms/FormStatusDirective';\n\n/**\n * @public\n *\n * Injection token for the default properties of the CalendarComponent.\n * Use this token to provide default properties for the CalendarComponent.\n * The properties will be applied to the component when it is created.\n * This is useful for setting default values for properties that are not set by the user.\n */\nexport const CALENDAR_DEFAULT_PROPS = new InjectionToken<Partial<CalendarElement.Props>>('MOSAIK_CALENDAR_DEFAULT_PROPS');\n\n/**\n * @public\n *\n * @slot footer - The footer slot.\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-calendar', CalendarElement),\n    inputs: ['intl', 'displayDate', 'displayDateStart', 'displayDateEnd', 'header', 'values', 'view', 'selectionMode', 'blackoutDates', 'specialDates', 'minDate', 'maxDate', 'firstDayOfWeek', 'isTodayHighlighted', 'isWeekendHighlighted', 'showWeekNumbers', 'showAdjacent', 'markerHandler', 'themeName', 'locale', 'appearance', 'disabled', 'invalid', 'value', 'orientation', 'variant', 'fit', 'dir', 'lang'],\n    methods: ['reset', 'checkValidity', 'navigatePrevious', 'navigateNext', 'navigateToday', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-calendar',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['intl', 'displayDate', 'displayDateStart', 'displayDateEnd', 'header', 'values', 'view', 'selectionMode', 'blackoutDates', 'specialDates', 'minDate', 'maxDate', 'firstDayOfWeek', 'isTodayHighlighted', 'isWeekendHighlighted', 'showWeekNumbers', 'showAdjacent', 'markerHandler', 'themeName', 'locale', 'appearance', 'disabled', 'invalid', 'value', 'orientation', 'variant', 'fit', 'dir', 'lang'],\n    outputs: ['dateChanged', 'connected', 'disconnected', 'changed'],\n    hostDirectives: [FormStatusDirective],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => CalendarComponent),\n            multi: true\n        },\n        {\n            provide: FORM_STATUS_HOST,\n            useExisting: forwardRef(() => CalendarComponent)\n        }\n    ]\n})\nexport class CalendarComponent implements ControlValueAccessor {\n    private readonly _element: CalendarElement;\n    private readonly _zone: NgZone;\n    private readonly _accessor: IElementValueAccessor;\n    private readonly _dateChanged: EventEmitter<unknown>;\n    private readonly _connected: EventEmitter<unknown>;\n    private readonly _disconnected: EventEmitter<unknown>;\n    private readonly _changed: EventEmitter<unknown>;\n\n    public constructor() {\n        inject(ChangeDetectorRef).detach();\n\n        this._element = inject(ElementRef).nativeElement;\n        this._zone = inject(NgZone);\n        this._accessor = calendarElementValueAccessor(this._element);\n        this._element.addController(this._accessor);\n        this._dateChanged = new EventEmitter<unknown>();\n        this._element.on('dateChanged', (e) => this.onEmit(this._dateChanged, e));\n        this._connected = new EventEmitter<unknown>();\n        this._element.on('connected', (e) => this.onEmit(this._connected, e));\n        this._disconnected = new EventEmitter<unknown>();\n        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));\n        this._changed = new EventEmitter<unknown>();\n        this._element.on('changed', (e) => this.onEmit(this._changed, e));\n\n        applyDefaults(this._element, inject(CALENDAR_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get intl(): CalendarElement['intl'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.intl;\n    }\n    public set intl(value: CalendarElement['intl']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.intl = value;\n        });\n    }\n\n    @Input()\n    public get displayDate(): CalendarElement['displayDate'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.displayDate;\n    }\n    public set displayDate(value: CalendarElement['displayDate']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.displayDate = value;\n        });\n    }\n\n    @Input()\n    public get displayDateStart(): CalendarElement['displayDateStart'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.displayDateStart;\n    }\n    public set displayDateStart(value: CalendarElement['displayDateStart']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.displayDateStart = value;\n        });\n    }\n\n    @Input()\n    public get displayDateEnd(): CalendarElement['displayDateEnd'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.displayDateEnd;\n    }\n    public set displayDateEnd(value: CalendarElement['displayDateEnd']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.displayDateEnd = value;\n        });\n    }\n\n    @Input()\n    public get header(): CalendarElement['header'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.header;\n    }\n    public set header(value: CalendarElement['header']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.header = value;\n        });\n    }\n\n    @Input()\n    public get values(): CalendarElement['values'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.values;\n    }\n    public set values(value: CalendarElement['values']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.values = value;\n        });\n    }\n\n    @Input()\n    public get view(): CalendarElement['view'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.view;\n    }\n    public set view(value: CalendarElement['view']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.view = value;\n        });\n    }\n\n    @Input()\n    public get selectionMode(): CalendarElement['selectionMode'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.selectionMode;\n    }\n    public set selectionMode(value: CalendarElement['selectionMode']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.selectionMode = value;\n        });\n    }\n\n    @Input()\n    public get blackoutDates(): CalendarElement['blackoutDates'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.blackoutDates;\n    }\n    public set blackoutDates(value: CalendarElement['blackoutDates']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.blackoutDates = value;\n        });\n    }\n\n    @Input()\n    public get specialDates(): CalendarElement['specialDates'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.specialDates;\n    }\n    public set specialDates(value: CalendarElement['specialDates']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.specialDates = value;\n        });\n    }\n\n    @Input()\n    public get minDate(): CalendarElement['minDate'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.minDate;\n    }\n    public set minDate(value: CalendarElement['minDate']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.minDate = value;\n        });\n    }\n\n    @Input()\n    public get maxDate(): CalendarElement['maxDate'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.maxDate;\n    }\n    public set maxDate(value: CalendarElement['maxDate']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.maxDate = value;\n        });\n    }\n\n    @Input()\n    public get firstDayOfWeek(): CalendarElement['firstDayOfWeek'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.firstDayOfWeek;\n    }\n    public set firstDayOfWeek(value: CalendarElement['firstDayOfWeek']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.firstDayOfWeek = value;\n        });\n    }\n\n    @Input()\n    public get isTodayHighlighted(): CalendarElement['isTodayHighlighted'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isTodayHighlighted;\n    }\n    public set isTodayHighlighted(value: CalendarElement['isTodayHighlighted']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isTodayHighlighted = value;\n        });\n    }\n\n    @Input()\n    public get isWeekendHighlighted(): CalendarElement['isWeekendHighlighted'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isWeekendHighlighted;\n    }\n    public set isWeekendHighlighted(value: CalendarElement['isWeekendHighlighted']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isWeekendHighlighted = value;\n        });\n    }\n\n    @Input()\n    public get showWeekNumbers(): CalendarElement['showWeekNumbers'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.showWeekNumbers;\n    }\n    public set showWeekNumbers(value: CalendarElement['showWeekNumbers']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.showWeekNumbers = value;\n        });\n    }\n\n    @Input()\n    public get showAdjacent(): CalendarElement['showAdjacent'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.showAdjacent;\n    }\n    public set showAdjacent(value: CalendarElement['showAdjacent']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.showAdjacent = value;\n        });\n    }\n\n    @Input()\n    public get markerHandler(): CalendarElement['markerHandler'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.markerHandler;\n    }\n    public set markerHandler(value: CalendarElement['markerHandler']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.markerHandler = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): CalendarElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: CalendarElement['themeName']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.themeName = value;\n        });\n    }\n\n    @Input()\n    public get locale(): CalendarElement['locale'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.locale;\n    }\n    public set locale(value: CalendarElement['locale']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.locale = value;\n        });\n    }\n\n    @Input()\n    public get appearance(): CalendarElement['appearance'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.appearance;\n    }\n    public set appearance(value: CalendarElement['appearance']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.appearance = value;\n        });\n    }\n\n    @Input()\n    public get disabled(): CalendarElement['disabled'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.disabled;\n    }\n    public set disabled(value: CalendarElement['disabled']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.disabled = value;\n        });\n    }\n\n    @Input()\n    public get invalid(): CalendarElement['invalid'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.invalid;\n    }\n    public set invalid(value: CalendarElement['invalid']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.invalid = value;\n        });\n    }\n\n    @Input()\n    public get value(): CalendarElement['value'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.value;\n    }\n    public set value(value: CalendarElement['value']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.value = value;\n        });\n    }\n\n    @Input()\n    public get orientation(): CalendarElement['orientation'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.orientation;\n    }\n    public set orientation(value: CalendarElement['orientation']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.orientation = value;\n        });\n    }\n\n    @Input()\n    public get variant(): CalendarElement['variant'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.variant;\n    }\n    public set variant(value: CalendarElement['variant']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.variant = value;\n        });\n    }\n\n    @Input()\n    public get fit(): CalendarElement['fit'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.fit;\n    }\n    public set fit(value: CalendarElement['fit']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.fit = value;\n        });\n    }\n\n    @Input()\n    public get dir(): CalendarElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: CalendarElement['dir']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.dir = value;\n        });\n    }\n\n    @Input()\n    public get lang(): CalendarElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: CalendarElement['lang']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.lang = value;\n        });\n    }\n\n    @Output()\n    public get dateChanged(): EventEmitter<unknown> {\n        return this._dateChanged;\n    }\n\n    @Output()\n    public get connected(): EventEmitter<unknown> {\n        return this._connected;\n    }\n\n    @Output()\n    public get disconnected(): EventEmitter<unknown> {\n        return this._disconnected;\n    }\n\n    @Output()\n    public get changed(): EventEmitter<unknown> {\n        return this._changed;\n    }\n\n    public writeValue(obj: unknown): void {\n        this._accessor.writeValue(obj);\n    }\n\n    public registerOnChange(fn: unknown): void {\n        this._accessor.registerOnChange(fn);\n    }\n\n    public registerOnTouched(fn: unknown): void {\n        this._accessor.registerOnTouched(fn);\n    }\n\n    public setDisabledState?(isDisabled: boolean): void {\n        this._accessor.setDisabled?.(isDisabled);\n    }\n\n    public invoke<TMethod extends CalendarMethodNames>(method: TMethod, ...args: Parameters<CalendarComponentMethods[TMethod]>): ReturnType<CalendarComponentMethods[TMethod]> {\n        return (this._element as any)[method](...args);\n    }\n\n    private onEmit<T>(emitter: EventEmitter<T>, event: Event): void {\n        if (event instanceof CustomEvent) {\n            emitter.emit(event.detail);\n        } else {\n            emitter.emit();\n        }\n    }\n}\n\n/**\n * Declares the methods available on CalendarComponent.\n */\nexport type CalendarMethodNames = 'reset' | 'checkValidity' | 'navigatePrevious' | 'navigateNext' | 'navigateToday' | 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for CalendarComponent.\n */\nexport type CalendarComponentMethods = MethodMap<CalendarMethodNames>;\n\n/**\n * @public\n */\nexport function provideCalendar(config: Partial<CalendarElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: CALENDAR_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}