@porscheinformatik/clr-addons 15.0.1 → 15.2.1

package/daterangepicker/providers/daterange-parsing.service.d.ts

@@ -0,0 +1,66 @@
+import { InputDateDisplayFormat } from '../daterange.constants';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import * as i0 from "@angular/core";
+/**
+ * Daterange parsing service.
+ * Heavy inspired by `date-io.service.ts` from Clarity.
+ * https://github.com/vmware-clarity/ng-clarity/blob/a21fe726fe91ae3c929b8f016359afe354bb89c6/projects/angular/src/forms/datepicker/providers/date-io.service.ts
+ */
+export declare class DaterangeParsingService {
+    private readonly locale;
+    readonly localeDisplayFormat: InputDateDisplayFormat;
+    readonly localeDelimiter: Array<string>;
+    /** Locale format. */
+    get localeFormat(): string;
+    constructor(locale: string);
+    /**
+     * Convert daterange to locale friendly text.
+     * @param daterange - Daterange.
+     * @param separator - Separator between 'from' and 'to' dates.
+     * @returns Friendly daterange text.
+     */
+    toLocaleString(daterange: NullableDaterange, separator?: string): string;
+    /**
+     * Convert date to locale display format string.
+     * @param date - Javascript Date object.
+     * @returns Locale display format string.
+     */
+    private toLocaleDisplayFormatString;
+    /**
+     * String padding with zeros.
+     * @param num - Number to pad.
+     * @returns Padded string.
+     */
+    private pad;
+    /**
+     * Parse daterange string to daterange object.
+     * @param daterangeString - Daterange string.
+     * @param separator - Separator text.
+     * @returns Daterange object.
+     */
+    parse(daterangeString: string, separator?: string): NullableDaterange;
+    /**
+     * Get `DayModel` from date string.
+     * @param dateString - Date string.
+     * @returns DayModel.
+     */
+    private getDayModelFromDateString;
+    /**
+     * Get `DayModel` from date string parts.
+     * @param yearString - Year string.
+     * @param monthString - Month string.
+     * @param dateString - Date string.
+     * @returns DayModel.
+     */
+    private getDayModelFromDateParts;
+    /**
+     * Takes in a year and if it is a 2 digit year, returns the corresponding 4 digit year.
+     * Window of 80 years before and 20 years after the present year.
+     * Credit: https://github.com/globalizejs/globalize/blob/e1b31cd6a4f1cff75b185b68b7a32220aac5196f/src/date/parse.js
+     * @param year - Year.
+     * @returns Four-digit year.
+     */
+    private parseToFourDigitYear;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaterangeParsingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaterangeParsingService>;
+}

package/daterangepicker/providers/daterange.service.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '@angular/core';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import { NullableDayModel } from '../models/day.model';
+import * as i0 from "@angular/core";
+/**
+ * Daterange service.
+ * Keeps track of daterange related values.
+ */
+export declare class DaterangeService {
+    /** Minimum date that can be selected. */
+    minDate: NullableDayModel;
+    /** Maximum date that can be selected. */
+    maxDate: NullableDayModel;
+    private _selectedDaterange;
+    /**
+     * Selected daterange value.
+     * @returns Selected daterange value.
+     */
+    get selectedDaterange(): NullableDaterange;
+    /**
+     * Set selected daterange value.
+     * @param value - New selected daterange value.
+     * @param triggerEvent - Trigger change event (default true).
+     */
+    updateSelectedDaterange(value: NullableDaterange, triggerEvent?: boolean): void;
+    /**
+     * Event triggered when value changes.
+     */
+    valueChange: EventEmitter<import("../interfaces/daterange.interface").Daterange>;
+    /**
+     * Checks if daterange is valid.
+     * Daterange is considered invalid when it's empty, or when one of it's properties is absent.
+     * @returns Wether daterange is valid.
+     */
+    isValid(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaterangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaterangeService>;
+}

package/daterangepicker/providers/opened-datepickers-tracker.service.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Keeps track of how many Clarity Datepicker there are open.
+ * This is needed for the ClrDaterangepickerContainerComponent, to know when to close the popover.
+ */
+export declare class OpenedDatepickersTrackerService {
+    private openedDatepickersCount;
+    /**
+     * Event triggered when value changes.
+     */
+    valueChange: EventEmitter<boolean>;
+    /**
+     * Tracks an opened datepicker.
+     * @param opened - Opened state.
+     */
+    track(opened: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenedDatepickersTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenedDatepickersTrackerService>;
+}

package/daterangepicker/validators/daterange-max.validator.d.ts

@@ -0,0 +1,32 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import { DaterangeService } from '../providers/daterange.service';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'to' date is not after 'max' value.
+ * Otherwise will throw corresponding `max` validation error.
+ *
+ * Validator is applied to the ClrDaterangepickerDirective with `max` attribute.
+ * Or when set manually with `clrDaterangeMax` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeMax]="false"`
+ */
+export declare class ClrDaterangeMaxValidator implements Validator {
+    private readonly daterangeService;
+    /** Validation error name. */
+    static readonly validationErrorName = "max";
+    private _active;
+    constructor(daterangeService: DaterangeService);
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active: boolean | string | undefined | null);
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control: AbstractControl<NullableDaterange, any>): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDaterangeMaxValidator, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDaterangeMaxValidator, "[clrDaterangepicker][max], [clrDaterangeMax]", never, { "active": "clrDaterangeMax"; }, {}, never, never, false, never>;
+}

package/daterangepicker/validators/daterange-min.validator.d.ts

@@ -0,0 +1,32 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import { DaterangeService } from '../providers/daterange.service';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'from' date is not before 'min' value.
+ * Otherwise will throw corresponding `min` validation error.
+ *
+ * Validator is applied to the ClrDaterangepickerDirective with `min` attribute.
+ * Or when set manually with `clrDaterangeMin` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeMin]="false"`
+ */
+export declare class ClrDaterangeMinValidator implements Validator {
+    private readonly daterangeService;
+    /** Validation error name. */
+    static readonly validationErrorName = "min";
+    private _active;
+    constructor(daterangeService: DaterangeService);
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active: boolean | string | undefined | null);
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control: AbstractControl<NullableDaterange, any>): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDaterangeMinValidator, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDaterangeMinValidator, "[clrDaterangepicker][min], [clrDaterangeMin]", never, { "active": "clrDaterangeMin"; }, {}, never, never, false, never>;
+}

package/daterangepicker/validators/daterange-order.validator.d.ts

@@ -0,0 +1,29 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'from' date is before 'to' date.
+ * Otherwise will throw `fromIsAfterTo` validation error.
+ *
+ * This validator is applied automatically on ClrDaterangepickerDirective.
+ * Or when set manually with `clrDaterangeOrder` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeOrder]="false"`
+ */
+export declare class ClrDaterangeOrderValidator implements Validator {
+    /** Validation error name. */
+    static readonly validationErrorName = "fromIsAfterTo";
+    private _active;
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active: boolean | string | undefined | null);
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control: AbstractControl<NullableDaterange, any>): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDaterangeOrderValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDaterangeOrderValidator, "[clrDaterangepicker], [clrDaterangeOrder]", never, { "active": "clrDaterangeOrder"; }, {}, never, never, false, never>;
+}

package/daterangepicker/validators/daterange-required.validator.d.ts

@@ -0,0 +1,29 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import { NullableDaterange } from '../interfaces/daterange.interface';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'from' *AND* 'to' date are not `null`.
+ * Will throw `required` validation error.
+ *
+ * Validator is applied to the ClrDaterangepickerDirective with `required` attribute.
+ * Or when set manually with `clrDaterangeRequired` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeRequired]="false"`
+ */
+export declare class ClrDaterangeRequiredValidator implements Validator {
+    /** Validation error name. */
+    static readonly validationErrorName = "required";
+    private _active;
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active: boolean | string | undefined | null);
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control: AbstractControl<NullableDaterange, any>): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDaterangeRequiredValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDaterangeRequiredValidator, "[clrDaterangepicker][required], [clrDaterangeRequired]", never, { "active": "clrDaterangeRequired"; }, {}, never, never, false, never>;
+}

package/dropdown/clr-dropdown-overflow.directive.d.ts

@@ -1,6 +1,6 @@
-import { AfterContentInit, ElementRef, OnDestroy } from '@angular/core';
+import { AfterContentChecked, ElementRef, OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class ClrDropdownOverflowDirective implements AfterContentInit, OnDestroy {
+export declare class ClrDropdownOverflowDirective implements AfterContentChecked, OnDestroy {
     private elRef;
     clrDropdownMenuMaxHeight: string | number;
     clrDropdownMenuItemMinHeight: string | number;
@@ -8,8 +8,9 @@ export declare class ClrDropdownOverflowDirective implements AfterContentInit, O
     readonly defaultItemMinHeightRem = 1.5;
     readonly marginBottomRem = 0.1;
     private destroy$;
+    private alreadyChecked;
     constructor(elRef: ElementRef);
-    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
     ngOnDestroy(): void;
     private applyDropdownOverflowStyles;
     private removeDropdownOverflowStyles;

package/esm2020/clr-addons.module.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2022 Porsche Informatik. All Rights Reserved.
+ * Copyright (c) 2018-2023 Porsche Informatik. All Rights Reserved.
  * This software is released under MIT license.
  * The full license information can be found in LICENSE in the root directory of this project.
  */
@@ -33,6 +33,7 @@ import { ClrFormModule } from './abstract-form-component/form.module';
 import { ClrDropdownOverflowModule } from './dropdown';
 import { ClrDatagridStatePersistenceModule, ClrEnumFilterModule } from './datagrid';
 import { ClrDateFilterModule } from './datagrid/date-filter/date-filter.module';
+import { ClrDaterangepickerModule } from './daterangepicker/daterangepicker.module';
 import * as i0 from "@angular/core";
 export class ClrAddonsModule {
 }
@@ -66,7 +67,8 @@ ClrAddonsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version
         ClrDropdownOverflowModule,
         ClrDatagridStatePersistenceModule,
         ClrEnumFilterModule,
-        ClrDateFilterModule] });
+        ClrDateFilterModule,
+        ClrDaterangepickerModule] });
 ClrAddonsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrAddonsModule, imports: [ClrViewEditSectionModule,
         ClrPagerModule,
         ClrDotPagerModule,
@@ -96,7 +98,8 @@ ClrAddonsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version
         ClrDropdownOverflowModule,
         ClrDatagridStatePersistenceModule,
         ClrEnumFilterModule,
-        ClrDateFilterModule] });
+        ClrDateFilterModule,
+        ClrDaterangepickerModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrAddonsModule, decorators: [{
             type: NgModule,
             args: [{
@@ -131,7 +134,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImpor
                         ClrDatagridStatePersistenceModule,
                         ClrEnumFilterModule,
                         ClrDateFilterModule,
+                        ClrDaterangepickerModule,
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clr-addons.module.js","sourceRoot":"","sources":["../../../src/clr-addons/clr-addons.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2022 Porsche Informatik. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { NgModule } from '@angular/core';\nimport { ClrBackButtonModule } from './back-button/back-button.module';\nimport { ClrBreadcrumbModule } from './breadcrumb/breadcrumb.module';\nimport { ClrCollapseExpandSectionModule } from './collapse-expand-section/collapse-expand-section.module';\nimport { ClrContentPanelModule } from './content-panel/content-panel.module';\nimport { ClrDataListValidatorModule } from './data-list-validator/data-list-validator.module';\nimport { ClrDateTimeModule } from './date-time-container/date-time-module';\nimport { ClrDotPagerModule } from './dot-pager/dot-pager.module';\nimport { ClrFlowBarModule } from './flow-bar/flow-bar.module';\nimport { ClrGenericQuickListModule } from './generic-quick-list/generic-quick-list.module';\nimport { ClrLetterAvatarModule } from './letter-avatar/letter-avatar.module';\nimport { ClrMainNavGroupModule } from './main-nav-group/main-nav-group.module';\nimport { ClrMultilingualModule } from './multilingual/multilingual.module';\nimport { ClrNotificationModule } from './notification/notification.module';\nimport { ClrNumericFieldModule } from './numericfield/numeric-field.module';\nimport { ClrPagedSearchResultListModule } from './paged-search-result-list/paged-search-result-list.module';\nimport { ClrPagerModule } from './pager/pager.module';\nimport { ClrProgressSpinnerModule } from './progress-spinner/progress-spinner.module';\nimport { ClrQuickListModule } from './quick-list/quick-list.module';\nimport { ClrSearchFieldModule } from './searchfield/search-field.module';\nimport { ClrTreetableModule } from './treetable/treetable.module';\nimport { ClrViewEditSectionModule } from './view-edit-section/view-edit-section.module';\nimport { ClrHistoryModule } from './history/history.module';\nimport { ClrAutocompleteOffModule } from './autocomplete-off/autocomplete-off.module';\nimport { ClrBrandAvatarModule } from './brand-avatar/brand-avatar.module';\nimport { ClrLocationBarModule } from './location-bar/location-bar.module';\nimport { ClrFormModule } from './abstract-form-component/form.module';\nimport { ClrDropdownOverflowModule } from './dropdown';\nimport { ClrDatagridStatePersistenceModule, ClrEnumFilterModule } from './datagrid';\nimport { ClrDateFilterModule } from './datagrid/date-filter/date-filter.module';\n\n@NgModule({\n  exports: [\n    ClrViewEditSectionModule,\n    ClrPagerModule,\n    ClrDotPagerModule,\n    ClrPagedSearchResultListModule,\n    ClrCollapseExpandSectionModule,\n    ClrBreadcrumbModule,\n    ClrMainNavGroupModule,\n    ClrContentPanelModule,\n    ClrNotificationModule,\n    ClrFlowBarModule,\n    ClrBackButtonModule,\n    ClrNumericFieldModule,\n    ClrSearchFieldModule,\n    ClrTreetableModule,\n    ClrProgressSpinnerModule,\n    ClrDateTimeModule,\n    ClrQuickListModule,\n    ClrLetterAvatarModule,\n    ClrMultilingualModule,\n    ClrGenericQuickListModule,\n    ClrDataListValidatorModule,\n    ClrHistoryModule,\n    ClrAutocompleteOffModule,\n    ClrBrandAvatarModule,\n    ClrLocationBarModule,\n    ClrFormModule,\n    ClrDropdownOverflowModule,\n    ClrDatagridStatePersistenceModule,\n    ClrEnumFilterModule,\n    ClrDateFilterModule,\n  ],\n})\nexport class ClrAddonsModule {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clr-addons.module.js","sourceRoot":"","sources":["../../../src/clr-addons/clr-addons.module.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,8BAA8B,EAAE,MAAM,0DAA0D,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,0BAA0B,EAAE,MAAM,kDAAkD,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,8BAA8B,EAAE,MAAM,4DAA4D,CAAC;AAC5G,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,iCAAiC,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;;AAqCpF,MAAM,OAAO,eAAe;;4GAAf,eAAe;6GAAf,eAAe,YAjCxB,wBAAwB;QACxB,cAAc;QACd,iBAAiB;QACjB,8BAA8B;QAC9B,8BAA8B;QAC9B,mBAAmB;QACnB,qBAAqB;QACrB,qBAAqB;QACrB,qBAAqB;QACrB,gBAAgB;QAChB,mBAAmB;QACnB,qBAAqB;QACrB,oBAAoB;QACpB,kBAAkB;QAClB,wBAAwB;QACxB,iBAAiB;QACjB,kBAAkB;QAClB,qBAAqB;QACrB,qBAAqB;QACrB,yBAAyB;QACzB,0BAA0B;QAC1B,gBAAgB;QAChB,wBAAwB;QACxB,oBAAoB;QACpB,oBAAoB;QACpB,aAAa;QACb,yBAAyB;QACzB,iCAAiC;QACjC,mBAAmB;QACnB,mBAAmB;QACnB,wBAAwB;6GAGf,eAAe,YAjCxB,wBAAwB;QACxB,cAAc;QACd,iBAAiB;QACjB,8BAA8B;QAC9B,8BAA8B;QAC9B,mBAAmB;QACnB,qBAAqB;QACrB,qBAAqB;QACrB,qBAAqB;QACrB,gBAAgB;QAChB,mBAAmB;QACnB,qBAAqB;QACrB,oBAAoB;QACpB,kBAAkB;QAClB,wBAAwB;QACxB,iBAAiB;QACjB,kBAAkB;QAClB,qBAAqB;QACrB,qBAAqB;QACrB,yBAAyB;QACzB,0BAA0B;QAC1B,gBAAgB;QAChB,wBAAwB;QACxB,oBAAoB;QACpB,oBAAoB;QACpB,aAAa;QACb,yBAAyB;QACzB,iCAAiC;QACjC,mBAAmB;QACnB,mBAAmB;QACnB,wBAAwB;2FAGf,eAAe;kBAnC3B,QAAQ;mBAAC;oBACR,OAAO,EAAE;wBACP,wBAAwB;wBACxB,cAAc;wBACd,iBAAiB;wBACjB,8BAA8B;wBAC9B,8BAA8B;wBAC9B,mBAAmB;wBACnB,qBAAqB;wBACrB,qBAAqB;wBACrB,qBAAqB;wBACrB,gBAAgB;wBAChB,mBAAmB;wBACnB,qBAAqB;wBACrB,oBAAoB;wBACpB,kBAAkB;wBAClB,wBAAwB;wBACxB,iBAAiB;wBACjB,kBAAkB;wBAClB,qBAAqB;wBACrB,qBAAqB;wBACrB,yBAAyB;wBACzB,0BAA0B;wBAC1B,gBAAgB;wBAChB,wBAAwB;wBACxB,oBAAoB;wBACpB,oBAAoB;wBACpB,aAAa;wBACb,yBAAyB;wBACzB,iCAAiC;wBACjC,mBAAmB;wBACnB,mBAAmB;wBACnB,wBAAwB;qBACzB;iBACF","sourcesContent":["/*\n * Copyright (c) 2018-2023 Porsche Informatik. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { NgModule } from '@angular/core';\nimport { ClrBackButtonModule } from './back-button/back-button.module';\nimport { ClrBreadcrumbModule } from './breadcrumb/breadcrumb.module';\nimport { ClrCollapseExpandSectionModule } from './collapse-expand-section/collapse-expand-section.module';\nimport { ClrContentPanelModule } from './content-panel/content-panel.module';\nimport { ClrDataListValidatorModule } from './data-list-validator/data-list-validator.module';\nimport { ClrDateTimeModule } from './date-time-container/date-time-module';\nimport { ClrDotPagerModule } from './dot-pager/dot-pager.module';\nimport { ClrFlowBarModule } from './flow-bar/flow-bar.module';\nimport { ClrGenericQuickListModule } from './generic-quick-list/generic-quick-list.module';\nimport { ClrLetterAvatarModule } from './letter-avatar/letter-avatar.module';\nimport { ClrMainNavGroupModule } from './main-nav-group/main-nav-group.module';\nimport { ClrMultilingualModule } from './multilingual/multilingual.module';\nimport { ClrNotificationModule } from './notification/notification.module';\nimport { ClrNumericFieldModule } from './numericfield/numeric-field.module';\nimport { ClrPagedSearchResultListModule } from './paged-search-result-list/paged-search-result-list.module';\nimport { ClrPagerModule } from './pager/pager.module';\nimport { ClrProgressSpinnerModule } from './progress-spinner/progress-spinner.module';\nimport { ClrQuickListModule } from './quick-list/quick-list.module';\nimport { ClrSearchFieldModule } from './searchfield/search-field.module';\nimport { ClrTreetableModule } from './treetable/treetable.module';\nimport { ClrViewEditSectionModule } from './view-edit-section/view-edit-section.module';\nimport { ClrHistoryModule } from './history/history.module';\nimport { ClrAutocompleteOffModule } from './autocomplete-off/autocomplete-off.module';\nimport { ClrBrandAvatarModule } from './brand-avatar/brand-avatar.module';\nimport { ClrLocationBarModule } from './location-bar/location-bar.module';\nimport { ClrFormModule } from './abstract-form-component/form.module';\nimport { ClrDropdownOverflowModule } from './dropdown';\nimport { ClrDatagridStatePersistenceModule, ClrEnumFilterModule } from './datagrid';\nimport { ClrDateFilterModule } from './datagrid/date-filter/date-filter.module';\nimport { ClrDaterangepickerModule } from './daterangepicker/daterangepicker.module';\n\n@NgModule({\n  exports: [\n    ClrViewEditSectionModule,\n    ClrPagerModule,\n    ClrDotPagerModule,\n    ClrPagedSearchResultListModule,\n    ClrCollapseExpandSectionModule,\n    ClrBreadcrumbModule,\n    ClrMainNavGroupModule,\n    ClrContentPanelModule,\n    ClrNotificationModule,\n    ClrFlowBarModule,\n    ClrBackButtonModule,\n    ClrNumericFieldModule,\n    ClrSearchFieldModule,\n    ClrTreetableModule,\n    ClrProgressSpinnerModule,\n    ClrDateTimeModule,\n    ClrQuickListModule,\n    ClrLetterAvatarModule,\n    ClrMultilingualModule,\n    ClrGenericQuickListModule,\n    ClrDataListValidatorModule,\n    ClrHistoryModule,\n    ClrAutocompleteOffModule,\n    ClrBrandAvatarModule,\n    ClrLocationBarModule,\n    ClrFormModule,\n    ClrDropdownOverflowModule,\n    ClrDatagridStatePersistenceModule,\n    ClrEnumFilterModule,\n    ClrDateFilterModule,\n    ClrDaterangepickerModule,\n  ],\n})\nexport class ClrAddonsModule {}\n"]}

package/esm2020/daterangepicker/daterange.constants.mjs

@@ -0,0 +1,27 @@
+export const USER_INPUT_REGEX = /\d+/g;
+// https://en.wikipedia.org/wiki/Date_format_by_country
+export const LITTLE_ENDIAN_REGEX = /d+.+m+.+y+/i;
+export const MIDDLE_ENDIAN_REGEX = /m+.+d+.+y+/i;
+export const DELIMITER_REGEX = /d+|m+|y+/i;
+export const YEAR = 'YYYY';
+export const MONTH = 'MM';
+export const DATE = 'DD';
+export const LITTLE_ENDIAN = {
+    name: 'LITTLE_ENDIAN',
+    format: [DATE, MONTH, YEAR],
+};
+export const MIDDLE_ENDIAN = {
+    name: 'MIDDLE_ENDIAN',
+    format: [MONTH, DATE, YEAR],
+};
+export const BIG_ENDIAN = {
+    name: 'BIG_ENDIAN',
+    format: [YEAR, MONTH, DATE],
+};
+/** Default separator text. */
+export const SEPARATOR_TEXT_DEFAULT = ' - ';
+export const TRANSLATIONS = {
+    from: 'From',
+    to: 'To',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/daterangepicker.module.mjs

@@ -0,0 +1,58 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { ClarityModule, ClrDatepickerModule, ClrIconModule } from '@clr/angular';
+import { ClrDatepickerComponent } from './directives/datepicker/datepicker.component';
+import { ClrDaterangepickerContainerComponent } from './directives/daterangepicker-container/daterangepicker-container.component';
+import { ClrDaterangepickerDirective } from './directives/daterangepicker/daterangepicker.directive';
+import { ClrIfDaterangeErrorDirective } from './directives/if-daterange-error.directive';
+import { ClrDaterangeMaxValidator } from './validators/daterange-max.validator';
+import { ClrDaterangeMinValidator } from './validators/daterange-min.validator';
+import { ClrDaterangeOrderValidator } from './validators/daterange-order.validator';
+import { ClrDaterangeRequiredValidator } from './validators/daterange-required.validator';
+import * as i0 from "@angular/core";
+export class ClrDaterangepickerModule {
+}
+ClrDaterangepickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrDaterangepickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangepickerModule, declarations: [ClrDatepickerComponent,
+        ClrDaterangeMaxValidator,
+        ClrDaterangeMinValidator,
+        ClrDaterangeOrderValidator,
+        ClrDaterangepickerContainerComponent,
+        ClrDaterangepickerDirective,
+        ClrDaterangeRequiredValidator,
+        ClrIfDaterangeErrorDirective], imports: [CommonModule, FormsModule, ClarityModule, ClrDatepickerModule, ClrIconModule], exports: [ClrDaterangeMaxValidator,
+        ClrDaterangeMinValidator,
+        ClrDaterangeOrderValidator,
+        ClrDaterangepickerContainerComponent,
+        ClrDaterangepickerDirective,
+        ClrDaterangeRequiredValidator,
+        ClrIfDaterangeErrorDirective] });
+ClrDaterangepickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangepickerModule, imports: [CommonModule, FormsModule, ClarityModule, ClrDatepickerModule, ClrIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, ClarityModule, ClrDatepickerModule, ClrIconModule],
+                    declarations: [
+                        ClrDatepickerComponent,
+                        ClrDaterangeMaxValidator,
+                        ClrDaterangeMinValidator,
+                        ClrDaterangeOrderValidator,
+                        ClrDaterangepickerContainerComponent,
+                        ClrDaterangepickerDirective,
+                        ClrDaterangeRequiredValidator,
+                        ClrIfDaterangeErrorDirective,
+                    ],
+                    entryComponents: [ClrDatepickerComponent],
+                    exports: [
+                        ClrDaterangeMaxValidator,
+                        ClrDaterangeMinValidator,
+                        ClrDaterangeOrderValidator,
+                        ClrDaterangepickerContainerComponent,
+                        ClrDaterangepickerDirective,
+                        ClrDaterangeRequiredValidator,
+                        ClrIfDaterangeErrorDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXJhbmdlcGlja2VyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jbHItYWRkb25zL2RhdGVyYW5nZXBpY2tlci9kYXRlcmFuZ2VwaWNrZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsYUFBYSxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUVqRixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUN0RixPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSw0RUFBNEUsQ0FBQztBQUNsSSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUNyRyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUN6RixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNoRixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNoRixPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUNwRixPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQzs7QUF5QjFGLE1BQU0sT0FBTyx3QkFBd0I7O3FIQUF4Qix3QkFBd0I7c0hBQXhCLHdCQUF3QixpQkFwQmpDLHNCQUFzQjtRQUN0Qix3QkFBd0I7UUFDeEIsd0JBQXdCO1FBQ3hCLDBCQUEwQjtRQUMxQixvQ0FBb0M7UUFDcEMsMkJBQTJCO1FBQzNCLDZCQUE2QjtRQUM3Qiw0QkFBNEIsYUFUcEIsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsbUJBQW1CLEVBQUUsYUFBYSxhQWFwRix3QkFBd0I7UUFDeEIsd0JBQXdCO1FBQ3hCLDBCQUEwQjtRQUMxQixvQ0FBb0M7UUFDcEMsMkJBQTJCO1FBQzNCLDZCQUE2QjtRQUM3Qiw0QkFBNEI7c0hBR25CLHdCQUF3QixZQXRCekIsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsbUJBQW1CLEVBQUUsYUFBYTsyRkFzQjNFLHdCQUF3QjtrQkF2QnBDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsbUJBQW1CLEVBQUUsYUFBYSxDQUFDO29CQUN2RixZQUFZLEVBQUU7d0JBQ1osc0JBQXNCO3dCQUN0Qix3QkFBd0I7d0JBQ3hCLHdCQUF3Qjt3QkFDeEIsMEJBQTBCO3dCQUMxQixvQ0FBb0M7d0JBQ3BDLDJCQUEyQjt3QkFDM0IsNkJBQTZCO3dCQUM3Qiw0QkFBNEI7cUJBQzdCO29CQUNELGVBQWUsRUFBRSxDQUFDLHNCQUFzQixDQUFDO29CQUN6QyxPQUFPLEVBQUU7d0JBQ1Asd0JBQXdCO3dCQUN4Qix3QkFBd0I7d0JBQ3hCLDBCQUEwQjt3QkFDMUIsb0NBQW9DO3dCQUNwQywyQkFBMkI7d0JBQzNCLDZCQUE2Qjt3QkFDN0IsNEJBQTRCO3FCQUM3QjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBDbGFyaXR5TW9kdWxlLCBDbHJEYXRlcGlja2VyTW9kdWxlLCBDbHJJY29uTW9kdWxlIH0gZnJvbSAnQGNsci9hbmd1bGFyJztcblxuaW1wb3J0IHsgQ2xyRGF0ZXBpY2tlckNvbXBvbmVudCB9IGZyb20gJy4vZGlyZWN0aXZlcy9kYXRlcGlja2VyL2RhdGVwaWNrZXIuY29tcG9uZW50JztcbmltcG9ydCB7IENsckRhdGVyYW5nZXBpY2tlckNvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vZGlyZWN0aXZlcy9kYXRlcmFuZ2VwaWNrZXItY29udGFpbmVyL2RhdGVyYW5nZXBpY2tlci1jb250YWluZXIuY29tcG9uZW50JztcbmltcG9ydCB7IENsckRhdGVyYW5nZXBpY2tlckRpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9kYXRlcmFuZ2VwaWNrZXIvZGF0ZXJhbmdlcGlja2VyLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBDbHJJZkRhdGVyYW5nZUVycm9yRGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL2lmLWRhdGVyYW5nZS1lcnJvci5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQ2xyRGF0ZXJhbmdlTWF4VmFsaWRhdG9yIH0gZnJvbSAnLi92YWxpZGF0b3JzL2RhdGVyYW5nZS1tYXgudmFsaWRhdG9yJztcbmltcG9ydCB7IENsckRhdGVyYW5nZU1pblZhbGlkYXRvciB9IGZyb20gJy4vdmFsaWRhdG9ycy9kYXRlcmFuZ2UtbWluLnZhbGlkYXRvcic7XG5pbXBvcnQgeyBDbHJEYXRlcmFuZ2VPcmRlclZhbGlkYXRvciB9IGZyb20gJy4vdmFsaWRhdG9ycy9kYXRlcmFuZ2Utb3JkZXIudmFsaWRhdG9yJztcbmltcG9ydCB7IENsckRhdGVyYW5nZVJlcXVpcmVkVmFsaWRhdG9yIH0gZnJvbSAnLi92YWxpZGF0b3JzL2RhdGVyYW5nZS1yZXF1aXJlZC52YWxpZGF0b3InO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZSwgQ2xhcml0eU1vZHVsZSwgQ2xyRGF0ZXBpY2tlck1vZHVsZSwgQ2xySWNvbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogW1xuICAgIENsckRhdGVwaWNrZXJDb21wb25lbnQsXG4gICAgQ2xyRGF0ZXJhbmdlTWF4VmFsaWRhdG9yLFxuICAgIENsckRhdGVyYW5nZU1pblZhbGlkYXRvcixcbiAgICBDbHJEYXRlcmFuZ2VPcmRlclZhbGlkYXRvcixcbiAgICBDbHJEYXRlcmFuZ2VwaWNrZXJDb250YWluZXJDb21wb25lbnQsXG4gICAgQ2xyRGF0ZXJhbmdlcGlja2VyRGlyZWN0aXZlLFxuICAgIENsckRhdGVyYW5nZVJlcXVpcmVkVmFsaWRhdG9yLFxuICAgIENscklmRGF0ZXJhbmdlRXJyb3JEaXJlY3RpdmUsXG4gIF0sXG4gIGVudHJ5Q29tcG9uZW50czogW0NsckRhdGVwaWNrZXJDb21wb25lbnRdLFxuICBleHBvcnRzOiBbXG4gICAgQ2xyRGF0ZXJhbmdlTWF4VmFsaWRhdG9yLFxuICAgIENsckRhdGVyYW5nZU1pblZhbGlkYXRvcixcbiAgICBDbHJEYXRlcmFuZ2VPcmRlclZhbGlkYXRvcixcbiAgICBDbHJEYXRlcmFuZ2VwaWNrZXJDb250YWluZXJDb21wb25lbnQsXG4gICAgQ2xyRGF0ZXJhbmdlcGlja2VyRGlyZWN0aXZlLFxuICAgIENsckRhdGVyYW5nZVJlcXVpcmVkVmFsaWRhdG9yLFxuICAgIENscklmRGF0ZXJhbmdlRXJyb3JEaXJlY3RpdmUsXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIENsckRhdGVyYW5nZXBpY2tlck1vZHVsZSB7fVxuIl19

package/esm2020/daterangepicker/directives/abstract-container.component.mjs

@@ -0,0 +1,104 @@
+import { ContentChild, Directive, HostBinding, Optional } from '@angular/core';
+import { ClrControlError, ClrControlHelper, ClrControlSuccess, ClrLabel, ClrLayout } from '@clr/angular';
+import { DaterangeControlStateService } from '../providers/daterange-control-state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@clr/angular";
+import * as i2 from "../providers/daterange-control-state.service";
+export class ClrAbstractContainer {
+    constructor(clrLayout, daterangeControlStateService) {
+        this.clrLayout = clrLayout;
+        this.daterangeControlStateService = daterangeControlStateService;
+        this.isFormControl = true;
+    }
+    /**
+     * Detect if container is not part of an vertical form to apply correct grid classes.
+     */
+    get addLayoutGrid() {
+        return !this.clrLayout?.layoutService?.isVertical();
+    }
+    /**
+     * Wether to show the helper control.
+     * @returns Wether to show the helper control.
+     */
+    get showHelper() {
+        if (this.controlHelperComponent == null) {
+            return false;
+        }
+        // Helper Component exist and the state of the form is NONE (not touched).
+        if (!this.daterangeControlStateService.touched) {
+            return true;
+        }
+        // Or there is no success component but the state of the form is VALID - show helper information.
+        if (this.controlSuccessComponent == null &&
+            this.daterangeControlStateService.touched &&
+            !this.daterangeControlStateService.invalid) {
+            return true;
+        }
+        // Or there is no error component but the state of the form is INVALID - show helper information.
+        if (this.controlErrorComponent == null && this.daterangeControlStateService.invalid) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Wether to show the valid control.
+     * @returns Wether to show the valid control.
+     */
+    get showValid() {
+        return !this.daterangeControlStateService.invalid && !!this.controlSuccessComponent;
+    }
+    /**
+     * Wether to show the invalid control.
+     * @returns Wether to show the invalid control.
+     */
+    get showInvalid() {
+        return this.daterangeControlStateService.invalid && !!this.controlErrorComponent;
+    }
+    /**
+     * Disabled state.
+     * @returns Disabled state.
+     */
+    get disabled() {
+        return this.daterangeControlStateService.disabled;
+    }
+    /**
+     * If control is focused.
+     * @returns Wether control is focused.
+     */
+    get focus() {
+        return this.daterangeControlStateService.focused;
+    }
+    /**
+     * Wether control is invalid.
+     * @returns Wether control is invalid.
+     */
+    get isInvalid() {
+        return this.daterangeControlStateService.invalid;
+    }
+}
+ClrAbstractContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrAbstractContainer, deps: [{ token: i1.ClrLayout, optional: true }, { token: i2.DaterangeControlStateService }], target: i0.ɵɵFactoryTarget.Directive });
+ClrAbstractContainer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", type: ClrAbstractContainer, host: { properties: { "class.clr-form-control": "this.isFormControl", "class.clr-row": "this.addLayoutGrid" } }, queries: [{ propertyName: "labelComponent", first: true, predicate: ClrLabel, descendants: true }, { propertyName: "controlHelperComponent", first: true, predicate: ClrControlHelper, descendants: true }, { propertyName: "controlErrorComponent", first: true, predicate: ClrControlError, descendants: true }, { propertyName: "controlSuccessComponent", first: true, predicate: ClrControlSuccess, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrAbstractContainer, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.ClrLayout, decorators: [{
+                    type: Optional
+                }] }, { type: i2.DaterangeControlStateService }]; }, propDecorators: { isFormControl: [{
+                type: HostBinding,
+                args: ['class.clr-form-control']
+            }], addLayoutGrid: [{
+                type: HostBinding,
+                args: ['class.clr-row']
+            }], labelComponent: [{
+                type: ContentChild,
+                args: [ClrLabel]
+            }], controlHelperComponent: [{
+                type: ContentChild,
+                args: [ClrControlHelper]
+            }], controlErrorComponent: [{
+                type: ContentChild,
+                args: [ClrControlError]
+            }], controlSuccessComponent: [{
+                type: ContentChild,
+                args: [ClrControlSuccess]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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