@vality/matez 19.0.0

package/fesm2022/vality-matez.mjs

@@ -0,0 +1,3809 @@
+import * as i1$1 from '@angular/common';
+import { CommonModule, AsyncPipe, formatCurrency as formatCurrency$1, getCurrencySymbol, formatDate, NgClass } from '@angular/common';
+import * as i0 from '@angular/core';
+import { ChangeDetectionStrategy, Component, NgModule, Input, EventEmitter, booleanAttribute, Output, HostBinding, InjectionToken, Optional, Inject, Injectable, inject, Directive, input, numberAttribute, ChangeDetectorRef, DestroyRef, forwardRef, LOCALE_ID, model, runInInjectionContext, Injector, output, viewChild, computed, signal, ElementRef, ViewChild, ContentChild, TemplateRef, ViewEncapsulation, DEFAULT_CURRENCY_CODE, Pipe } from '@angular/core';
+import * as i1$4 from '@angular/material/button';
+import { MatButtonModule, MatIconButton, MatButton } from '@angular/material/button';
+import * as i1$2 from '@angular/material/dialog';
+import { MatDialogModule, MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import * as i2 from '@angular/material/divider';
+import { MatDividerModule, MatDivider } from '@angular/material/divider';
+import * as i2$1 from '@angular/material/icon';
+import { MatIconModule, MatIcon } from '@angular/material/icon';
+import * as i1 from '@angular/material/progress-bar';
+import { MatProgressBarModule, MatProgressBar } from '@angular/material/progress-bar';
+import * as i10 from '@angular/cdk/drag-drop';
+import { CdkDrag, CdkDropList } from '@angular/cdk/drag-drop';
+import * as i1$3 from '@angular/forms';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, FormControl, ReactiveFormsModule, FormsModule } from '@angular/forms';
+import * as i6 from '@angular/material/badge';
+import { MatBadgeModule } from '@angular/material/badge';
+import * as i4 from '@angular/material/card';
+import { MatCardModule } from '@angular/material/card';
+import * as i9 from '@angular/material/sort';
+import { MatSort, MatSortModule } from '@angular/material/sort';
+import * as i2$4 from '@angular/material/table';
+import { MatTableDataSource, MatTable, MatColumnDef, MatCellDef, MatHeaderCellDef, MatFooterCellDef, MatTableModule, MatRow } from '@angular/material/table';
+import * as i2$5 from '@angular/material/tooltip';
+import { MatTooltip, MatTooltipModule } from '@angular/material/tooltip';
+import { random, get, difference, isEqual as isEqual$1, capitalize, lowerFirst, isArray } from 'lodash-es';
+import * as i2$2 from '@angular/material/input';
+import { MatInputModule } from '@angular/material/input';
+import startCase from 'lodash-es/startCase';
+import { isPrimitive } from 'utility-types';
+import { isObservable, defer, merge, combineLatest, mergeMap, EMPTY, catchError, of, scan, takeLast, from, switchMap, ReplaySubject, debounce, interval, concat, timer, take, fromEvent, filter as filter$1, map as map$1, startWith as startWith$1, distinctUntilChanged as distinctUntilChanged$1, shareReplay as shareReplay$1, BehaviorSubject, Observable, debounceTime as debounceTime$1, Subject, tap, first as first$1, forkJoin, lastValueFrom, timeout, skipWhile, race, skip, mergeScan, takeUntil, throttleTime } from 'rxjs';
+import { finalize, map, delay, startWith, distinctUntilChanged, shareReplay, catchError as catchError$1, filter, first, debounceTime, share } from 'rxjs/operators';
+import { isPromise } from 'rxjs/internal/util/isPromise';
+import { takeUntilDestroyed, toSignal, toObservable, outputFromObservable } from '@angular/core/rxjs-interop';
+import { WrappedControlSuperclass, FormComponentSuperclass as FormComponentSuperclass$1 } from '@s-libs/ng-core';
+import omitBy from 'lodash-es/omitBy';
+import isNil from 'lodash-es/isNil';
+import * as currencies from '@dinero.js/currencies';
+import round from 'lodash-es/round';
+import isEqual from 'lodash-es/isEqual';
+import lodashIsEmpty from 'lodash-es/isEmpty';
+import isObject$1 from 'lodash-es/isObject';
+import * as papaparse from 'papaparse';
+import papaparse__default from 'papaparse';
+import * as i3 from '@angular/material/form-field';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import * as i2$3 from '@angular/material/chips';
+import { MatChipsModule } from '@angular/material/chips';
+import * as i1$6 from '@angular/router';
+import { RouterModule, RouterLink } from '@angular/router';
+export { MtxTooltip as Tooltip } from '@ng-matero/extensions/tooltip';
+import { MatMenu, MatMenuItem, MatMenuTrigger } from '@angular/material/menu';
+import * as i1$5 from '@angular/material/slide-toggle';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i3$1 from '@angular/material/checkbox';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import * as i2$6 from '@angular/cdk/layout';
+import { Breakpoints, LayoutModule } from '@angular/cdk/layout';
+import * as i2$7 from '@angular/material/datepicker';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import * as i6$1 from '@angular/material/core';
+import { MAT_DATE_LOCALE, DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
+import { DateFnsAdapter, MAT_DATE_FNS_FORMATS } from '@angular/material-date-fns-adapter';
+import { enGB } from 'date-fns/locale';
+import { isEqual as isEqual$2, endOfDay, subDays, startOfDay, format, isValid, formatDistanceToNow } from 'date-fns';
+import * as i3$2 from '@ng-matero/extensions/select';
+import { MtxSelectModule } from '@ng-matero/extensions/select';
+import * as i5 from '@angular/material/autocomplete';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import * as i1$7 from '@angular/common/http';
+import * as i1$8 from '@angular/material/snack-bar';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import negate from 'lodash-es/negate';
+
+class ActionsComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: ActionsComponent, isStandalone: false, selector: "v-actions", ngImport: i0, template: "<div class=\"v-actions\">\n    <ng-content></ng-content>\n</div>\n", styles: ["::ng-deep .v-actions{box-sizing:border-box;display:flex;flex-wrap:wrap;gap:16px}::ng-deep .v-actions>*:first-child:not(:last-child){margin-right:auto}::ng-deep .v-actions>*:first-child:last-child{margin-left:auto}@media screen and (max-width: 600px){::ng-deep .v-actions>*{margin-left:auto!important;margin-right:auto!important}}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-actions', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<div class=\"v-actions\">\n    <ng-content></ng-content>\n</div>\n", styles: ["::ng-deep .v-actions{box-sizing:border-box;display:flex;flex-wrap:wrap;gap:16px}::ng-deep .v-actions>*:first-child:not(:last-child){margin-right:auto}::ng-deep .v-actions>*:first-child:last-child{margin-left:auto}@media screen and (max-width: 600px){::ng-deep .v-actions>*{margin-left:auto!important;margin-right:auto!important}}\n"] }]
+        }] });
+
+class ActionsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ActionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ActionsModule, declarations: [ActionsComponent], exports: [ActionsComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ActionsModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ActionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [ActionsComponent],
+                    exports: [ActionsComponent],
+                }]
+        }] });
+
+class ProgressComponent {
+    get mode() {
+        return typeof this.progress === 'number' && this.progress <= 1 && this.progress > 0
+            ? 'determinate'
+            : !!this.progress || this.progress === ''
+                ? 'indeterminate'
+                : undefined;
+    }
+    get value() {
+        return this.mode === 'determinate'
+            ? Math.max(Math.min((1 - this.progress) * 100, 100), 0)
+            : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ProgressComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: ProgressComponent, isStandalone: false, selector: "v-progress", inputs: { progress: "progress" }, ngImport: i0, template: "@if (!!mode) {\n    <mat-progress-bar [mode]=\"mode\" [value]=\"value\"></mat-progress-bar>\n}\n", dependencies: [{ kind: "component", type: i1.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-progress', standalone: false, template: "@if (!!mode) {\n    <mat-progress-bar [mode]=\"mode\" [value]=\"value\"></mat-progress-bar>\n}\n" }]
+        }], propDecorators: { progress: [{
+                type: Input
+            }] } });
+
+class ProgressModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ProgressModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ProgressModule, declarations: [ProgressComponent], imports: [CommonModule, MatProgressBarModule], exports: [ProgressComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ProgressModule, imports: [CommonModule, MatProgressBarModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ProgressModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ProgressComponent],
+                    imports: [CommonModule, MatProgressBarModule],
+                    exports: [ProgressComponent],
+                }]
+        }] });
+
+class DialogActionsComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: DialogActionsComponent, isStandalone: false, selector: "v-dialog-actions", ngImport: i0, template: "<v-actions><ng-content></ng-content></v-actions>\n", dependencies: [{ kind: "component", type: ActionsComponent, selector: "v-actions" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-dialog-actions', standalone: false, template: "<v-actions><ng-content></ng-content></v-actions>\n" }]
+        }] });
+
+var DialogResponseStatus;
+(function (DialogResponseStatus) {
+    DialogResponseStatus["Success"] = "success";
+    DialogResponseStatus["Error"] = "error";
+    DialogResponseStatus["Cancelled"] = "canceled";
+})(DialogResponseStatus || (DialogResponseStatus = {}));
+
+class DialogComponent {
+    constructor() {
+        this.hostClass = true;
+        this.disabled = false;
+        this.hasDivider = true;
+        this.noContent = false;
+        this.noActions = false;
+        this.noCloseButton = false;
+        this.fullSize = false;
+        // eslint-disable-next-line @angular-eslint/no-output-native
+        this.cancel = new EventEmitter();
+        this.cancelData = {
+            status: DialogResponseStatus.Cancelled,
+        };
+    }
+    cancelDialog() {
+        this.cancel.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: DialogComponent, isStandalone: false, selector: "v-dialog", inputs: { title: "title", disabled: ["disabled", "disabled", booleanAttribute], progress: "progress", hasDivider: ["hasDivider", "hasDivider", booleanAttribute], noContent: ["noContent", "noContent", booleanAttribute], noActions: ["noActions", "noActions", booleanAttribute], noCloseButton: ["noCloseButton", "noCloseButton", booleanAttribute], fullSize: ["fullSize", "fullSize", booleanAttribute] }, outputs: { cancel: "cancel" }, host: { properties: { "class.v-dialog": "this.hostClass" } }, ngImport: i0, template: "<div [ngClass]=\"{ 'full-size': fullSize }\" class=\"dialog\">\n    <div class=\"dialog-title\">\n        <div>\n            <h2 class=\"title\">{{ title }}</h2>\n        </div>\n        @if (!noCloseButton) {\n            <mat-icon\n                [matDialogClose]=\"cancelData\"\n                class=\"dialog-title-close\"\n                inline\n                (click)=\"cancelDialog()\"\n                >clear</mat-icon\n            >\n        }\n    </div>\n\n    @if (!noContent) {\n        @if (hasDivider) {\n            <mat-divider></mat-divider>\n        }\n        <div class=\"dialog-content\">\n            <ng-content></ng-content>\n        </div>\n    }\n    @if (!noActions) {\n        @if (hasDivider) {\n            <mat-divider></mat-divider>\n        }\n        <div class=\"dialog-actions\">\n            <ng-content select=\"v-dialog-actions\"></ng-content>\n        </div>\n    }\n\n    <v-progress [progress]=\"progress\"></v-progress>\n</div>\n", styles: [":host{display:flex;flex-direction:column;flex-grow:1;height:100%}.dialog{flex-direction:column;box-sizing:border-box;display:flex;flex:1 1 100%;max-height:calc(90vh - 48px)!important}@media screen and (max-width: 959px){.dialog{max-height:calc(100vh - 48px)!important}}.dialog.full-size{min-height:calc(90vh - 48px)!important}@media screen and (max-width: 959px){.dialog.full-size{min-height:calc(100vh - 48px)!important}}.dialog-title{flex-direction:row;box-sizing:border-box;display:flex;place-content:center space-between;align-items:center;padding:24px}.dialog-title h1,.dialog-title h2,.dialog-title h3,.dialog-title h4,.dialog-title h5,.dialog-title h6{margin:0}.dialog-title-close.dialog-title-close{cursor:pointer;font-size:24px}.dialog-title-close.dialog-title-close:hover{opacity:.5}.dialog-content{flex:1 1 100%;box-sizing:border-box;padding:24px;overflow:auto;display:grid}.dialog-actions{padding:24px}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: i2.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i1$2.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "component", type: ProgressComponent, selector: "v-progress", inputs: ["progress"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-dialog', standalone: false, template: "<div [ngClass]=\"{ 'full-size': fullSize }\" class=\"dialog\">\n    <div class=\"dialog-title\">\n        <div>\n            <h2 class=\"title\">{{ title }}</h2>\n        </div>\n        @if (!noCloseButton) {\n            <mat-icon\n                [matDialogClose]=\"cancelData\"\n                class=\"dialog-title-close\"\n                inline\n                (click)=\"cancelDialog()\"\n                >clear</mat-icon\n            >\n        }\n    </div>\n\n    @if (!noContent) {\n        @if (hasDivider) {\n            <mat-divider></mat-divider>\n        }\n        <div class=\"dialog-content\">\n            <ng-content></ng-content>\n        </div>\n    }\n    @if (!noActions) {\n        @if (hasDivider) {\n            <mat-divider></mat-divider>\n        }\n        <div class=\"dialog-actions\">\n            <ng-content select=\"v-dialog-actions\"></ng-content>\n        </div>\n    }\n\n    <v-progress [progress]=\"progress\"></v-progress>\n</div>\n", styles: [":host{display:flex;flex-direction:column;flex-grow:1;height:100%}.dialog{flex-direction:column;box-sizing:border-box;display:flex;flex:1 1 100%;max-height:calc(90vh - 48px)!important}@media screen and (max-width: 959px){.dialog{max-height:calc(100vh - 48px)!important}}.dialog.full-size{min-height:calc(90vh - 48px)!important}@media screen and (max-width: 959px){.dialog.full-size{min-height:calc(100vh - 48px)!important}}.dialog-title{flex-direction:row;box-sizing:border-box;display:flex;place-content:center space-between;align-items:center;padding:24px}.dialog-title h1,.dialog-title h2,.dialog-title h3,.dialog-title h4,.dialog-title h5,.dialog-title h6{margin:0}.dialog-title-close.dialog-title-close{cursor:pointer;font-size:24px}.dialog-title-close.dialog-title-close:hover{opacity:.5}.dialog-content{flex:1 1 100%;box-sizing:border-box;padding:24px;overflow:auto;display:grid}.dialog-actions{padding:24px}\n"] }]
+        }], propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.v-dialog']
+            }], title: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], progress: [{
+                type: Input
+            }], hasDivider: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], noContent: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], noActions: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], noCloseButton: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], fullSize: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], cancel: [{
+                type: Output
+            }] } });
+
+const DIALOG_CONFIG = new InjectionToken('dialogConfig');
+const BASE_CONFIG = {
+    maxHeight: '100vh',
+    disableClose: true,
+    autoFocus: false,
+    minWidth: '0',
+    maxWidth: 'calc(100vw - 16px)',
+    width: '552px',
+};
+const DEFAULT_DIALOG_CONFIG = {
+    small: {
+        ...BASE_CONFIG,
+        width: '360px',
+    },
+    medium: BASE_CONFIG,
+    large: {
+        ...BASE_CONFIG,
+        width: '1000px',
+    },
+};
+const DEFAULT_DIALOG_CONFIG_FULL_HEIGHT = 'calc(90vh - 48px)';
+
+class DialogService {
+    constructor(dialog, dialogConfig) {
+        this.dialog = dialog;
+        this.dialogConfig = dialogConfig;
+        if (!dialogConfig) {
+            this.dialogConfig = DEFAULT_DIALOG_CONFIG;
+        }
+    }
+    open(dialogComponent, 
+    /**
+     *  Workaround when both conditions for the 'data' argument must be true:
+     *  - typing did not require passing when it is optional (for example: {param: number} | void)
+     *  - typing required to pass when it is required (for example: {param: number})
+     */
+    ...[data, configOrConfigName]) {
+        let config;
+        if (!configOrConfigName) {
+            config = {};
+        }
+        else if (typeof configOrConfigName === 'string') {
+            config = this.dialogConfig[configOrConfigName];
+        }
+        else {
+            config = configOrConfigName;
+        }
+        return this.dialog.open(dialogComponent, {
+            data,
+            ...dialogComponent.defaultDialogConfig,
+            ...config,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogService, deps: [{ token: i1$2.MatDialog }, { token: DIALOG_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$2.MatDialog }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DIALOG_CONFIG]
+                }] }] });
+
+class DialogModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: DialogModule, declarations: [DialogComponent, DialogActionsComponent], imports: [CommonModule,
+            MatDividerModule,
+            MatButtonModule,
+            ActionsModule,
+            MatIconModule,
+            MatProgressBarModule,
+            MatDialogModule,
+            ProgressModule], exports: [DialogComponent, DialogActionsComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogModule, providers: [DialogService], imports: [CommonModule,
+            MatDividerModule,
+            MatButtonModule,
+            ActionsModule,
+            MatIconModule,
+            MatProgressBarModule,
+            MatDialogModule,
+            ProgressModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatDividerModule,
+                        MatButtonModule,
+                        ActionsModule,
+                        MatIconModule,
+                        MatProgressBarModule,
+                        MatDialogModule,
+                        ProgressModule,
+                    ],
+                    providers: [DialogService],
+                    declarations: [DialogComponent, DialogActionsComponent],
+                    exports: [DialogComponent, DialogActionsComponent],
+                }]
+        }] });
+
+class DialogSuperclass {
+    constructor() {
+        this.dialogData = inject(MAT_DIALOG_DATA);
+        this.dialogRef = inject(MatDialogRef);
+    }
+    static { this.defaultDialogConfig = DEFAULT_DIALOG_CONFIG.medium; }
+    closeWithCancellation(data) {
+        this.dialogRef.close({
+            status: DialogResponseStatus.Cancelled,
+            data,
+        });
+    }
+    closeWithSuccess(data) {
+        this.dialogRef.close({
+            status: DialogResponseStatus.Success,
+            data,
+        });
+    }
+    closeWithError(data) {
+        this.dialogRef.close({
+            status: DialogResponseStatus.Error,
+            data,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogSuperclass, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: DialogSuperclass, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DialogSuperclass, decorators: [{
+            type: Directive
+        }] });
+
+class ContentLoadingComponent {
+    constructor() {
+        this.width = input(random(35, 80) + '%');
+        this.textSize = input(0, { transform: numberAttribute });
+        this.hiddenText = input();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ContentLoadingComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.2", type: ContentLoadingComponent, isStandalone: true, selector: "v-content-loading", inputs: { width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, textSize: { classPropertyName: "textSize", publicName: "textSize", isSignal: true, isRequired: false, transformFunction: null }, hiddenText: { classPropertyName: "hiddenText", publicName: "hiddenText", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<span\n    [ngClass]=\"{ 'content-loading__text': !!hiddenText() }\"\n    [style.width]=\"hiddenText() || textSize() ? undefined : width()\"\n    class=\"content-loading\"\n    >{{ hiddenText() || '&nbsp;'.repeat(textSize() || 1) }}</span\n>\n", styles: ["@keyframes content-loading-animation{0%{opacity:1}50%{opacity:.4}to{opacity:1}}.content-loading{color:transparent;display:inline-block;line-height:100%;background-color:#00000014;animation:content-loading-animation 1.5s ease-in-out infinite}.content-loading__text{color:inherit;background-color:transparent}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ContentLoadingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-content-loading', changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule], template: "<span\n    [ngClass]=\"{ 'content-loading__text': !!hiddenText() }\"\n    [style.width]=\"hiddenText() || textSize() ? undefined : width()\"\n    class=\"content-loading\"\n    >{{ hiddenText() || '&nbsp;'.repeat(textSize() || 1) }}</span\n>\n", styles: ["@keyframes content-loading-animation{0%{opacity:1}50%{opacity:.4}to{opacity:1}}.content-loading{color:transparent;display:inline-block;line-height:100%;background-color:#00000014;animation:content-loading-animation 1.5s ease-in-out infinite}.content-loading__text{color:inherit;background-color:transparent}\n"] }]
+        }] });
+
+function renderList(list, renderItem, isMore) {
+    return list.length ? (isMore ? '…' : list.map(renderItem).join(', ')) : '';
+}
+function isObject(v) {
+    return (typeof v === 'object' &&
+        !Array.isArray(v) &&
+        !(v instanceof Map) &&
+        !(v instanceof Set) &&
+        v !== null);
+}
+function inlineJson(value, maxReadableLever = 1, readableKeys = false, level = 0) {
+    const isRoot = (level = 0);
+    if (isPrimitive(value)) {
+        return String(value);
+    }
+    if (Array.isArray(value) || value instanceof Map || value instanceof Set) {
+        const content = renderList(Array.from(value), (v) => inlineJson(v, maxReadableLever, readableKeys, level + 1), level > maxReadableLever);
+        if (value instanceof Set) {
+            return `Set(${content})`;
+        }
+        if (value instanceof Map) {
+            return `Map(${content})`;
+        }
+        return isRoot && content ? content : `[${content}]`;
+    }
+    const entries = Array.from(Object.entries(value));
+    if (!entries.length) {
+        return '{}';
+    }
+    const content = renderList(entries, ([k, v]) => (readableKeys ? startCase(k) : k) +
+        (isObject(v) && Object.keys(v).length <= 1 ? '/' : ': ') +
+        inlineJson(v, maxReadableLever, readableKeys, level + 1), level > maxReadableLever);
+    if (isRoot || entries.length === 1) {
+        return content;
+    }
+    return `{${content}}`;
+}
+
+const SEPARATORS = ',;';
+function splitBySeparators(ids, separators = SEPARATORS) {
+    if (!ids) {
+        return [];
+    }
+    return ids
+        .split(new RegExp(`[${separators}\\s]`))
+        .map((id) => id.trim())
+        .filter(Boolean);
+}
+
+function progressTo(subject$) {
+    const getSub = () => (isObservable(subject$) ? subject$ : subject$());
+    return (src$) => defer(() => {
+        getSub().next(getSub().getValue() + 1);
+        return src$.pipe(finalize(() => getSub().next(getSub().getValue() - 1)));
+    });
+}
+
+function getObservable(obsOrFn) {
+    return typeof obsOrFn === 'function' ? defer(obsOrFn) : obsOrFn;
+}
+
+function inProgressFrom(progress, main, init = true) {
+    const progresses = (Array.isArray(progress) ? progress : [progress]).map((p) => getObservable(p));
+    return merge(combineLatest(progresses), main ? getObservable(main).pipe(mergeMap(() => EMPTY)) : EMPTY).pipe(map((ps) => ps.some((p) => !!p)), 
+    // make async to bypass angular detect changes
+    delay(0), startWith(init), distinctUntilChanged(), shareReplay({ refCount: true, bufferSize: 1 }));
+}
+
+function passError(handler, value) {
+    return (source) => source.pipe(catchError((err) => {
+        handler(err);
+        if (arguments.length >= 2) {
+            return of(value);
+        }
+        return EMPTY;
+    }));
+}
+
+function getProgressByCount(count, completedCount = Number.MIN_VALUE) {
+    return 1 - completedCount / count;
+}
+
+function forkJoinToResult(sources, progress$, dataItems = [], concurrency = 4) {
+    let completed = 0;
+    if (progress$) {
+        progress$.next(getProgressByCount(sources.length));
+    }
+    return merge(...sources.map((source, index) => source.pipe(map((result) => ({
+        result,
+        hasError: false,
+        index,
+        data: dataItems[index],
+    })), catchError((error) => {
+        return of({
+            error,
+            hasError: true,
+            index,
+            data: dataItems[index],
+        });
+    }), finalize(() => {
+        completed += 1;
+        if (progress$) {
+            progress$.next(getProgressByCount(sources.length, completed));
+        }
+    }))), concurrency).pipe(scan((acc, value) => {
+        acc.push(value);
+        return acc;
+    }, []), takeLast(1), map((r) => r.sort((a, b) => a.index - b.index)));
+}
+function isResultsHasError(res) {
+    return res.some((r) => r.hasError);
+}
+function splitResultsErrors(res) {
+    return res.reduce((acc, r) => {
+        acc[r.hasError ? 1 : 0].push(r);
+        return acc;
+    }, [[], []]);
+}
+
+function isAsync(value) {
+    return isObservable(value) || isPromise(value);
+}
+
+function getPossiblyAsyncObservable(possiblyAsync) {
+    return isAsync(possiblyAsync) ? from(possiblyAsync) : of(possiblyAsync);
+}
+
+class AsyncTransform {
+    constructor() {
+        this.params$ = defer(() => this.args$).pipe(switchMap((args) => combineLatest([
+            getPossiblyAsyncObservable(args[0]),
+            of(args.slice(1)),
+        ])), map(([value, params]) => [value, ...params]));
+        this.cdr = inject(ChangeDetectorRef);
+        this.args$ = new ReplaySubject(1);
+        this.asyncPipe = new AsyncPipe(this.cdr);
+    }
+    ngOnDestroy() {
+        this.asyncPipe.ngOnDestroy();
+    }
+    asyncTransform(args) {
+        this.args$.next(args);
+        return this.asyncPipe.transform(this.result$);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AsyncTransform, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AsyncTransform }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AsyncTransform, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+function switchCombineWith(project) {
+    return (src$) => src$.pipe(switchMap((value, index) => {
+        const res = project(value, index);
+        return combineLatest([
+            of(value),
+            ...(Array.isArray(res) ? res : [res]).map((r) => getPossiblyAsyncObservable(r)),
+        ]);
+    }));
+}
+
+function debounceTimeWithFirst(duration) {
+    return (source) => {
+        let isFirst = true;
+        return source.pipe(debounce(() => {
+            if (isFirst) {
+                isFirst = false;
+                return interval(0);
+            }
+            return interval(duration);
+        }));
+    };
+}
+
+function handleError(handler, result = EMPTY) {
+    return (source) => source.pipe(catchError$1((err, _caught) => {
+        handler(err);
+        return getPossiblyAsyncObservable(result);
+    }));
+}
+
+function asyncStartWith(value, timerMs = 0) {
+    return (src$) => concat(...(value ? [of(value)] : []), timer(timerMs).pipe(switchMap(() => src$)));
+}
+
+function hasControls(control) {
+    return 'controls' in control;
+}
+
+function getValue$1(control) {
+    if (!hasControls(control)) {
+        return control.value;
+    }
+    if (Array.isArray(control.controls)) {
+        const result = [];
+        for (const v of control.controls) {
+            result.push(getValue$1(v));
+        }
+        return result;
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(control.controls)) {
+        result[k] = getValue$1(v);
+    }
+    return result;
+}
+
+function getValueChanges(form) {
+    return form.valueChanges.pipe(startWith(form.value), map(() => getValue$1(form)));
+}
+
+/**
+ * FormGroup/FormArray don't return internal control errors,
+ * so you need to get internal errors manually
+ */
+function getErrorsTree(control) {
+    if (control.valid) {
+        return null;
+    }
+    const errors = Object.assign({}, control.errors);
+    if (hasControls(control)) {
+        if (Array.isArray(control.controls)) {
+            errors['formArrayErrors'] = control.controls
+                .map((c) => getErrorsTree(c))
+                .filter(Boolean);
+        }
+        else {
+            errors['formGroupErrors'] = Object.fromEntries(Array.from(Object.entries(control.controls))
+                .map(([k, c]) => [k, getErrorsTree(c)])
+                .filter(([, v]) => !!v));
+        }
+    }
+    return errors;
+}
+
+class AbstractControlSuperclass extends WrappedControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this._cdr = inject(ChangeDetectorRef);
+        this._destroyRef = inject(DestroyRef);
+        this.onValidatorChange = () => undefined;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        concat(timer(0), timer(100))
+            .pipe(filter(() => this.control.invalid), take(1), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this.onValidatorChange();
+            this._cdr.markForCheck();
+        });
+    }
+    validate(_control) {
+        return getErrorsTree(this.control); //|| getErrorsTree(_control);
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    setUpInnerToOuterErrors$() {
+        return EMPTY;
+    }
+    setUpOuterToInnerErrors$() {
+        return EMPTY;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AbstractControlSuperclass, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: AbstractControlSuperclass, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AbstractControlSuperclass, decorators: [{
+            type: Directive
+        }] });
+
+class FormGroupSuperclass extends AbstractControlSuperclass {
+    setDisabledState(_isDisabled) {
+        return;
+    }
+    ngOnInit() {
+        this.emptyValue = getValue$1(this.control);
+        super.ngOnInit();
+    }
+    outerToInnerValue(outer) {
+        if (hasControls(this.control)) {
+            if (!outer) {
+                return this.emptyValue;
+            }
+            if (Object.keys(outer).length < Object.keys(this.control.controls).length) {
+                return Object.assign({}, this.emptyValue, outer);
+            }
+        }
+        return outer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormGroupSuperclass, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: FormGroupSuperclass, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormGroupSuperclass, decorators: [{
+            type: Directive
+        }] });
+
+const provideValidators = (component) => ({
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(component),
+    multi: true,
+});
+
+const provideValueAccessor = (component) => ({
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(component),
+    multi: true,
+});
+
+const createControlProviders = (component) => [
+    provideValueAccessor(component),
+    provideValidators(component),
+];
+
+class FormControlSuperclass extends AbstractControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.control = new FormControl();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormControlSuperclass, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: FormControlSuperclass, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormControlSuperclass, decorators: [{
+            type: Directive
+        }] });
+
+class FormComponentSuperclass extends FormComponentSuperclass$1 {
+    constructor() {
+        super(...arguments);
+        this._cdr = inject(ChangeDetectorRef);
+        this._destroyRef = inject(DestroyRef);
+        this.onValidatorChange = () => undefined;
+    }
+    validate(_control) {
+        return null;
+    }
+    ngOnInit() {
+        concat(timer(0), timer(100))
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this.onValidatorChange();
+            this._cdr.markForCheck();
+        });
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormComponentSuperclass, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: FormComponentSuperclass, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FormComponentSuperclass, decorators: [{
+            type: Directive
+        }] });
+
+function isEmptyPrimitive(value) {
+    return isNil(value) || value === '';
+}
+
+function getValidValueChanges(control, predicate = isEmptyPrimitive) {
+    return getValueChanges(control).pipe(filter(() => control.valid), map((value) => omitBy(value, predicate)));
+}
+
+function setDisabled(control, disabled = true, options = {}) {
+    if (!control || control.disabled === disabled) {
+        return;
+    }
+    if (disabled) {
+        control.disable(options);
+    }
+    else {
+        control.enable(options);
+    }
+}
+
+function createControls(values) {
+    return Object.fromEntries(Object.entries(values).map(([k, v]) => [k, new FormControl(v, { nonNullable: true })]));
+}
+
+function getTimeZoneOffset(date) {
+    return date.getTimezoneOffset() * 60_000;
+}
+function getNoTimeZoneIsoString(date) {
+    return date ? new Date(date.valueOf() - getTimeZoneOffset(date)).toISOString() : '';
+}
+function createDateFromNoTimeZoneString(dateStr) {
+    const date = new Date(dateStr);
+    return new Date(date.valueOf() + getTimeZoneOffset(date));
+}
+
+const getCurrencyExponent = (currencyCode) => currencies[currencyCode]?.exponent;
+
+const toMajorByExponent = (amount, exponent) => round(amount / 10 ** exponent, exponent);
+const toMajor = (amount, currencyCode) => toMajorByExponent(amount, getCurrencyExponent(currencyCode));
+
+const toMinorByExponent = (amount, exponent) => Math.round(amount * 10 ** exponent);
+const toMinor = (amount, currencyCode) => toMinorByExponent(amount, getCurrencyExponent(currencyCode));
+
+function formatCurrency(amount, currencyCode = 'USD', format = 'long', locale = 'en-GB', exponent, isMajor = false) {
+    if (typeof exponent !== 'number') {
+        exponent = getCurrencyExponent(currencyCode) || 0;
+    }
+    return formatCurrency$1(isMajor ? amount : toMajorByExponent(amount, exponent), locale, getCurrencySymbol(currencyCode, 'narrow', locale), currencyCode, format === 'short' ? `1.0-${exponent}` : `1.${exponent}-${exponent}`);
+}
+
+function select(obj, selectFn, defaultValue, restParams = []) {
+    if (typeof selectFn === 'string') {
+        return get(obj, selectFn, defaultValue);
+    }
+    return selectFn(obj, ...restParams);
+}
+// export function selectAsObservable<TObject extends object, TResult, TParams extends Array<unknown> = []>(
+//     obj: TObject,
+//     selectFn: SelectFn<TObject, TResult, TParams>,
+//     defaultValue?: TResult,
+//     restParams: TParams[] = [],
+// ): TResult | Observable<TResult> {
+//     const res = select(obj, selectFn, defaultValue, restParams);
+//     return isObservable(res) ? res : of(res);
+// }
+
+function countProps(...objects) {
+    return objects.reduce((acc, obj) => acc + (obj ? Object.keys(obj).length : 0), 0);
+}
+
+function isEmpty(value) {
+    return isObject$1(value)
+        ? value.constructor === Object ||
+            Array.isArray(value) ||
+            value instanceof Set ||
+            value instanceof Map
+            ? lodashIsEmpty(value)
+            : false
+        : isEmptyPrimitive(value);
+}
+
+function countChanged(a, b, 
+// is equal boolean or count number
+predicates = {}) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    const diffKeys = difference(aKeys, bKeys);
+    const sameKeys = difference(aKeys, diffKeys);
+    return sameKeys
+        .map((k) => {
+        if (k in predicates) {
+            const res = predicates[k]?.(a[k], b[k]);
+            return typeof res === 'boolean' ? +!res : Number(res);
+        }
+        return (isEmpty(a[k]) && isEmpty(b[k])) || isEqual(a[k], b[k]) ? 0 : 1;
+    })
+        .reduce((sum, v) => sum + v, diffKeys.length);
+}
+
+function getEnumEntries(srcEnum) {
+    if (!srcEnum) {
+        return [];
+    }
+    const entries = Object.entries(srcEnum);
+    if (!entries.length) {
+        return [];
+    }
+    const isValueNumberEnum = entries.some(([, v]) => typeof v === 'number');
+    if (isValueNumberEnum) {
+        return entries.filter(([, v]) => typeof v === 'number');
+    }
+    return entries;
+}
+function getEnumKeyValues(srcEnum) {
+    return getEnumEntries(srcEnum).map(([key, value]) => ({ key, value }));
+}
+function getEnumKeys(srcEnum) {
+    return getEnumEntries(srcEnum).map(([k]) => k);
+}
+function getEnumValues(srcEnum) {
+    return getEnumEntries(srcEnum).map(([, v]) => v);
+}
+function getEnumKey(srcEnum, value) {
+    return getEnumKeyValues(srcEnum).find((e) => String(e.value) === String(value))?.key;
+}
+function enumHasValue(srcEnum, value) {
+    return getEnumValues(srcEnum).includes(value);
+}
+
+function clean(obj, allowRootRemoval = false, isNotDeep = false, filterPredicate = (v) => !isEmpty(v)) {
+    if (allowRootRemoval && !filterPredicate(obj)) {
+        return null;
+    }
+    const cleanChild = (v) => isNotDeep ? v : clean(v, true, isNotDeep, filterPredicate);
+    if (Array.isArray(obj)) {
+        return obj
+            .map((v) => cleanChild(v))
+            .filter((v, idx) => filterPredicate(v, idx));
+    }
+    if (obj?.constructor === Object) {
+        return Object.fromEntries(Object.entries(obj)
+            .map(([k, v]) => [k, cleanChild(v)])
+            .filter(([k, v]) => filterPredicate(v, k)));
+    }
+    return obj;
+}
+function cleanPrimitiveProps(obj, allowRootRemoval = false, isNotDeep = false) {
+    return clean(obj, allowRootRemoval, isNotDeep, (v) => !isEmptyPrimitive(v));
+}
+
+function isNumber(v) {
+    return !!v && (typeof v === 'number' || /^-?\d+.*$/.test(String(v).trim()));
+}
+function toNumber(v) {
+    return typeof v === 'string'
+        ? parseFloat(v.replace(',', '.').replace(/[^0-9.-]+/g, ''))
+        : Number(v);
+}
+/**
+ * Use with sorting (arr.sort(fn))
+ */
+function compareDifferentTypes(a, b) {
+    const aIsNum = isNumber(a);
+    const bIsNum = isNumber(b);
+    if (aIsNum || bIsNum) {
+        if (aIsNum && bIsNum) {
+            return toNumber(a) - toNumber(b);
+        }
+        else if (aIsNum) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+    return String(a).localeCompare(String(b));
+}
+
+function getImportValue(imp, prop = 'default') {
+    return from(imp).pipe(map((module) => {
+        if (!prop) {
+            return module;
+        }
+        return get(module, prop, null);
+    }));
+}
+
+const FILE_TYPES = {
+    csv: {
+        type: 'text/csv',
+        format: 'csv',
+    },
+};
+function downloadFile(data, type, filename = 'data') {
+    const blob = new Blob([data], { type: FILE_TYPES[type].type });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `${filename}.${FILE_TYPES[type].format}`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+}
+
+function createCsv(data) {
+    return papaparse.unparse(data);
+}
+
+function removeLineBreaks(str) {
+    return str.replace(/^[\r\n\s]+|[\r\n\s]+$/g, '');
+}
+
+function parseCsv(content, config) {
+    return papaparse__default.parse(removeLineBreaks(content), config);
+}
+
+function unifyCsvItems(csv, defaultProps) {
+    if (!Array.isArray(csv)) {
+        return [];
+    }
+    if (Array.isArray(csv?.[0])) {
+        return csv.map((d) => Object.fromEntries(d.map((prop, idx) => [defaultProps[idx], prop])));
+    }
+    return csv;
+}
+
+function arrayAttribute(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value;
+}
+
+function DebounceTime(ms = 500) {
+    return function (target, propertyKey, descriptor) {
+        let timer = null;
+        const method = descriptor.value;
+        descriptor.value = function () {
+            if (timer !== null) {
+                window.clearTimeout(timer);
+            }
+            timer = window.setTimeout(() => {
+                // eslint-disable-next-line prefer-rest-params
+                method.apply(this, arguments);
+                timer = null;
+            }, ms);
+        };
+    };
+}
+
+function createStorageValue(key, { serialize = (v) => (v === null ? null : String(v)), deserialize, injector, }) {
+    const value$ = fromEvent(document, 'storage').pipe(filter$1((v) => v.key === key), map$1((v) => v.newValue), startWith$1(localStorage.getItem(key)), map$1((v) => deserialize(v)), distinctUntilChanged$1(), shareReplay$1({ refCount: true, bufferSize: 1 }));
+    return {
+        get() {
+            return deserialize(localStorage.getItem(key));
+        },
+        set(value) {
+            const serialized = serialize(value);
+            if (serialized === null) {
+                return localStorage.removeItem(key);
+            }
+            return localStorage.setItem(key, serialized);
+        },
+        value$,
+        value: toSignal(value$, { injector }),
+    };
+}
+
+class InputFieldComponent extends FormControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.placeholder = '';
+        this.type = 'string';
+        this.appearance = 'fill';
+        this.cleanButton = input(false, { transform: booleanAttribute });
+        this.icon = input();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InputFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: InputFieldComponent, isStandalone: false, selector: "v-input-field", inputs: { label: { classPropertyName: "label", publicName: "label", isSignal: false, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: false, isRequired: false, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: false, isRequired: false, transformFunction: null }, appearance: { classPropertyName: "appearance", publicName: "appearance", isSignal: false, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: false, isRequired: false, transformFunction: null }, cleanButton: { classPropertyName: "cleanButton", publicName: "cleanButton", isSignal: true, isRequired: false, transformFunction: null }, icon: { classPropertyName: "icon", publicName: "icon", isSignal: true, isRequired: false, transformFunction: null } }, providers: createControlProviders(() => InputFieldComponent), usesInheritance: true, ngImport: i0, template: "<mat-form-field\n    [appearance]=\"appearance\"\n    [ngClass]=\"{\n        'v-input-field__small': size === 'small',\n        'v-input-field__outline': appearance === 'outline',\n    }\"\n    class=\"v-input-field\"\n>\n    @if (icon()) {\n        <div class=\"prefix\" matPrefix>\n            <mat-icon>{{ icon() }}</mat-icon>\n        </div>\n    }\n    <mat-label>{{ label }}</mat-label>\n    <input\n        [formControl]=\"control\"\n        [placeholder]=\"placeholder\"\n        [type]=\"type\"\n        autocomplete=\"false\"\n        matInput\n    />\n    <div class=\"postfix\" matSuffix>\n        @if (cleanButton()) {\n            <button\n                [disabled]=\"!control.value\"\n                [style.visibility]=\"control.value ? '' : 'hidden'\"\n                mat-icon-button\n                (click)=\"control.reset()\"\n            >\n                <mat-icon>clear</mat-icon>\n            </button>\n        }\n    </div>\n</mat-form-field>\n", styles: [".v-input-field .postfix{white-space:nowrap}.v-input-field__small ::ng-deep .mat-icon{transform:scale(.75)!important}.v-input-field__outline .postfix{padding-right:4px}.v-input-field__outline .prefix{padding-left:4px}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "directive", type: i3.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i1$4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InputFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-input-field', providers: createControlProviders(() => InputFieldComponent), standalone: false, template: "<mat-form-field\n    [appearance]=\"appearance\"\n    [ngClass]=\"{\n        'v-input-field__small': size === 'small',\n        'v-input-field__outline': appearance === 'outline',\n    }\"\n    class=\"v-input-field\"\n>\n    @if (icon()) {\n        <div class=\"prefix\" matPrefix>\n            <mat-icon>{{ icon() }}</mat-icon>\n        </div>\n    }\n    <mat-label>{{ label }}</mat-label>\n    <input\n        [formControl]=\"control\"\n        [placeholder]=\"placeholder\"\n        [type]=\"type\"\n        autocomplete=\"false\"\n        matInput\n    />\n    <div class=\"postfix\" matSuffix>\n        @if (cleanButton()) {\n            <button\n                [disabled]=\"!control.value\"\n                [style.visibility]=\"control.value ? '' : 'hidden'\"\n                mat-icon-button\n                (click)=\"control.reset()\"\n            >\n                <mat-icon>clear</mat-icon>\n            </button>\n        }\n    </div>\n</mat-form-field>\n", styles: [".v-input-field .postfix{white-space:nowrap}.v-input-field__small ::ng-deep .mat-icon{transform:scale(.75)!important}.v-input-field__outline .postfix{padding-right:4px}.v-input-field__outline .prefix{padding-left:4px}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }] } });
+
+class InputFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InputFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: InputFieldModule, declarations: [InputFieldComponent], imports: [CommonModule, MatInputModule, ReactiveFormsModule, MatIcon, MatIconButton], exports: [InputFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InputFieldModule, imports: [CommonModule, MatInputModule, ReactiveFormsModule, MatIcon, MatIconButton] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InputFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [InputFieldComponent],
+                    exports: [InputFieldComponent],
+                    imports: [CommonModule, MatInputModule, ReactiveFormsModule, MatIcon, MatIconButton],
+                }]
+        }] });
+
+class TagComponent {
+    constructor() {
+        this.hostClass = true;
+        this.icon = input();
+        this.progress = input(false, { transform: booleanAttribute });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TagComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: TagComponent, isStandalone: false, selector: "v-tag", inputs: { color: { classPropertyName: "color", publicName: "color", isSignal: false, isRequired: false, transformFunction: null }, icon: { classPropertyName: "icon", publicName: "icon", isSignal: true, isRequired: false, transformFunction: null }, progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.v-tag": "this.hostClass" } }, ngImport: i0, template: "<mat-chip-row\n    [disabled]=\"progress()\"\n    [ngClass]=\"{ loading: progress(), action: !!icon() }\"\n    class=\"tag {{ 'color-' + color }}\"\n    disableRipple\n>\n    @if (icon()) {\n        <button matChipRemove>\n            <mat-icon>{{ progress() ? 'autorenew' : icon() }}</mat-icon>\n        </button>\n    }\n    <ng-content></ng-content>\n</mat-chip-row>\n", styles: [":host ::ng-deep{pointer-events:none}:host .action ::ng-deep{pointer-events:auto;cursor:pointer}:host .action ::ng-deep button{pointer-events:none}:host ::ng-deep *:before{border:none!important}@keyframes content-loading-animation{0%{opacity:1}50%{opacity:.5}to{opacity:1}}.tag{transition:all .3s ease-in-out}.loading{animation:content-loading-animation 1.5s ease-in-out infinite}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2$3.MatChipRemove, selector: "[matChipRemove]" }, { kind: "component", type: i2$3.MatChipRow, selector: "mat-chip-row, [mat-chip-row], mat-basic-chip-row, [mat-basic-chip-row]", inputs: ["editable"], outputs: ["edited"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TagComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-tag', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<mat-chip-row\n    [disabled]=\"progress()\"\n    [ngClass]=\"{ loading: progress(), action: !!icon() }\"\n    class=\"tag {{ 'color-' + color }}\"\n    disableRipple\n>\n    @if (icon()) {\n        <button matChipRemove>\n            <mat-icon>{{ progress() ? 'autorenew' : icon() }}</mat-icon>\n        </button>\n    }\n    <ng-content></ng-content>\n</mat-chip-row>\n", styles: [":host ::ng-deep{pointer-events:none}:host .action ::ng-deep{pointer-events:auto;cursor:pointer}:host .action ::ng-deep button{pointer-events:none}:host ::ng-deep *:before{border:none!important}@keyframes content-loading-animation{0%{opacity:1}50%{opacity:.5}to{opacity:1}}.tag{transition:all .3s ease-in-out}.loading{animation:content-loading-animation 1.5s ease-in-out infinite}\n"] }]
+        }], propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.v-tag']
+            }], color: [{
+                type: Input
+            }] } });
+
+class TagModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TagModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: TagModule, declarations: [TagComponent], imports: [CommonModule, MatChipsModule, MatIconModule], exports: [TagComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TagModule, imports: [CommonModule, MatChipsModule, MatIconModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TagModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TagComponent],
+                    imports: [CommonModule, MatChipsModule, MatIconModule],
+                    exports: [TagComponent],
+                }]
+        }] });
+
+const SPACES = /[\s\u00A0]/g;
+function normalizeString(str) {
+    return (str || '').replace(SPACES, ' ');
+}
+
+class HighlightDirective {
+    constructor(el, renderer, dr, injector) {
+        this.el = el;
+        this.renderer = renderer;
+        this.dr = dr;
+        this.injector = injector;
+        this.vHighlightText = input('', { transform: (v) => String(v || '') });
+        this.vHighlightSearch = input('', { transform: (v) => String(v || '') });
+    }
+    ngOnInit() {
+        combineLatest([
+            toObservable(this.vHighlightText, { injector: this.injector }).pipe(distinctUntilChanged(), map((text) => this.escapeHtml(text))),
+            toObservable(this.vHighlightSearch, { injector: this.injector }).pipe(distinctUntilChanged(), map((text) => this.escapeHtml(text))),
+        ])
+            .pipe(map(([text, search]) => {
+            if (!search) {
+                return text;
+            }
+            const re = new RegExp(`(${search.replace(SPACES, '\\s')})`, 'gi');
+            return text.replace(re, `<mark>$1</mark>`);
+        }), distinctUntilChanged(), takeUntilDestroyed(this.dr))
+            .subscribe((text) => {
+            this.renderer.setProperty(this.el.nativeElement, 'innerHTML', text);
+        });
+    }
+    escapeHtml(html) {
+        return html
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: HighlightDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.DestroyRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.2", type: HighlightDirective, isStandalone: true, selector: "[vHighlight]", inputs: { vHighlightText: { classPropertyName: "vHighlightText", publicName: "vHighlightText", isSignal: true, isRequired: false, transformFunction: null }, vHighlightSearch: { classPropertyName: "vHighlightSearch", publicName: "vHighlightSearch", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: HighlightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[vHighlight]',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.DestroyRef }, { type: i0.Injector }] });
+
+class MenuValueComponent {
+    constructor() {
+        this.value = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MenuValueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: MenuValueComponent, isStandalone: true, selector: "v-menu-value", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: ` @if (value(); as v) {
+        <button [matMenuTriggerFor]="menu" class="button" mat-icon-button>
+            <mat-icon>more_vert</mat-icon>
+        </button>
+        <mat-menu #menu="matMenu">
+            @for (item of v.params.items; track item; let index = $index) {
+                <button [disabled]="!!item?.disabled" mat-menu-item (click)="item?.click?.($event)">
+                    {{ item.label }}
+                </button>
+            }
+        </mat-menu>
+    }`, isInline: true, styles: [""], dependencies: [{ kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MenuValueComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-menu-value', imports: [MatIcon, MatIconButton, MatMenu, MatMenuItem, MatMenuTrigger], template: ` @if (value(); as v) {
+        <button [matMenuTriggerFor]="menu" class="button" mat-icon-button>
+            <mat-icon>more_vert</mat-icon>
+        </button>
+        <mat-menu #menu="matMenu">
+            @for (item of v.params.items; track item; let index = $index) {
+                <button [disabled]="!!item?.disabled" mat-menu-item (click)="item?.click?.($event)">
+                    {{ item.label }}
+                </button>
+            }
+        </mat-menu>
+    }` }]
+        }] });
+
+class ToggleValueComponent {
+    constructor() {
+        this.value = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ToggleValueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: ToggleValueComponent, isStandalone: true, selector: "v-toggle-value", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: ` @if (value(); as v) {
+        <mat-slide-toggle
+            [checked]="value().value"
+            (change)="$event.source.checked = !!value().value"
+        >
+        </mat-slide-toggle>
+    }`, isInline: true, dependencies: [{ kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i1$5.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon", "disabledInteractive"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ToggleValueComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'v-toggle-value',
+                    imports: [MatSlideToggleModule],
+                    template: ` @if (value(); as v) {
+        <mat-slide-toggle
+            [checked]="value().value"
+            (change)="$event.source.checked = !!value().value"
+        >
+        </mat-slide-toggle>
+    }`,
+                }]
+        }] });
+
+function currencyAmountValueToString(value) {
+    if (typeof value?.value !== 'number') {
+        return '';
+    }
+    const locale = inject(LOCALE_ID);
+    return formatCurrency(value.value, value.params.code, 'long', locale, value.params.exponent, !!value.params.major);
+}
+
+function datetimeValueToString(value) {
+    if (!value?.value) {
+        return '';
+    }
+    const locale = inject(LOCALE_ID);
+    return formatDate(value.value, 'dd.MM.yyyy HH:mm:ss', locale, '+0000');
+}
+
+function unknownToString(value) {
+    if (isNil(value)) {
+        return '';
+    }
+    return String(value);
+}
+
+function valueToString(value) {
+    switch (value?.type) {
+        case 'currency':
+            return currencyAmountValueToString(value);
+        case 'datetime':
+            return datetimeValueToString(value);
+    }
+    return unknownToString(value?.value)?.trim?.();
+}
+
+class ValueComponent {
+    constructor(injector, router) {
+        this.injector = injector;
+        this.router = router;
+        this.value = input();
+        this.lazyValue = input();
+        this.lazyVisible = model(false);
+        this.progress = input(false, { transform: booleanAttribute });
+        this.inline = false;
+        this.emptySymbol = '―';
+        this.value$ = combineLatest([toObservable(this.value), toObservable(this.lazyValue)]).pipe(switchMap(([value, lazyValue]) => (isObservable(lazyValue) ? lazyValue : of(value))), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.valueText$ = this.value$.pipe(map((value) => runInInjectionContext(this.injector, () => valueToString(value))), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.inProgress$ = combineLatest([
+            toObservable(this.progress),
+            this.value$.pipe(map((v) => v?.inProgress ?? false)),
+        ]).pipe(map(([compProgress, valueProgress]) => compProgress || valueProgress), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    makeLazyVisible() {
+        this.lazyVisible.set(true);
+    }
+    click(event) {
+        this.value$.pipe(first(), filter(Boolean)).subscribe((value) => {
+            runInInjectionContext(this.injector, () => {
+                if (value?.click) {
+                    value.click(event);
+                }
+                else if (typeof value?.link === 'function') {
+                    const linkArgs = value.link(event);
+                    if (typeof linkArgs === 'string') {
+                        this.router.navigateByUrl(linkArgs);
+                        return;
+                    }
+                    this.router.navigate(...linkArgs);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ValueComponent, deps: [{ token: i0.Injector }, { token: i1$6.Router }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: ValueComponent, isStandalone: true, selector: "v-value", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, lazyValue: { classPropertyName: "lazyValue", publicName: "lazyValue", isSignal: true, isRequired: false, transformFunction: null }, lazyVisible: { classPropertyName: "lazyVisible", publicName: "lazyVisible", isSignal: true, isRequired: false, transformFunction: null }, progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null }, inline: { classPropertyName: "inline", publicName: "inline", isSignal: false, isRequired: false, transformFunction: booleanAttribute }, emptySymbol: { classPropertyName: "emptySymbol", publicName: "emptySymbol", isSignal: false, isRequired: false, transformFunction: (v) => (v === false ? '' : typeof v === 'string' ? v : '―') }, highlight: { classPropertyName: "highlight", publicName: "highlight", isSignal: false, isRequired: false, transformFunction: null } }, outputs: { lazyVisible: "lazyVisibleChange" }, host: { properties: { "class.inline": "inline" } }, ngImport: i0, template: "@if (!value() && lazyValue() && !lazyVisible()) {\n    <button class=\"button\" mat-icon-button (click)=\"lazyVisible.set(true)\">\n        <mat-icon>sync</mat-icon>\n    </button>\n} @else {\n    @if (value$ | async; as v) {\n        <div\n            [ngClass]=\"{ wrapper__action: v.click || v.link }\"\n            class=\"wrapper\"\n            (click)=\"click($event)\"\n        >\n            @if (v.template) {\n                <ng-container *ngTemplateOutlet=\"v.template; context: {}\"></ng-container>\n            } @else {\n                @if (v.color) {\n                    <v-tag [color]=\"v.color\">\n                        <ng-container *ngTemplateOutlet=\"tooltipTemplate\"></ng-container>\n                    </v-tag>\n                } @else {\n                    <ng-container *ngTemplateOutlet=\"tooltipTemplate\"></ng-container>\n                }\n\n                <ng-template #tooltipTemplate>\n                    @if (v.tooltip) {\n                        <span [matTooltip]=\"v.tooltip\" class=\"tooltip\">\n                            <ng-container *ngTemplateOutlet=\"valueTemplate\"></ng-container>\n                        </span>\n                    } @else {\n                        <span [title]=\"v.value\">\n                            <ng-container *ngTemplateOutlet=\"valueTemplate\"></ng-container>\n                        </span>\n                    }\n                </ng-template>\n\n                <ng-template #valueTemplate>\n                    @switch (v.type) {\n                        @case ('menu') {\n                            <v-menu-value [value]=\"v\"></v-menu-value>\n                        }\n                        @case ('toggle') {\n                            <v-toggle-value [value]=\"v\"></v-toggle-value>\n                        }\n                        @default {\n                            @let valueText = valueText$ | async;\n                            @if (inProgress$ | async) {\n                                <v-content-loading [hiddenText]=\"valueText\"></v-content-loading>\n                            } @else if (valueText) {\n                                <span\n                                    [ngClass]=\"{ value__click: v.click, value__link: v.link }\"\n                                    [vHighlightSearch]=\"highlight\"\n                                    [vHighlightText]=\"valueText\"\n                                    vHighlight\n                                ></span>\n                            } @else if (emptySymbol) {\n                                <span style=\"color: #ccc\">{{ emptySymbol }}</span>\n                            }\n                        }\n                    }\n                </ng-template>\n            }\n\n            @if (v.description) {\n                <div\n                    [title]=\"v.description\"\n                    [vHighlightSearch]=\"highlight\"\n                    [vHighlightText]=\"v.description\"\n                    class=\"description mat-label-medium mat-secondary-text\"\n                    vHighlight\n                ></div>\n            }\n        </div>\n    } @else {\n        <v-content-loading></v-content-loading>\n    }\n}\n", styles: [":host{cursor:default;text-align:left}::ng-deep .inline,::ng-deep .inline *{white-space:nowrap}.tooltip{text-decoration:underline;text-decoration-style:dotted}.wrapper__action{cursor:pointer}.value__click:hover{text-decoration:underline;text-decoration-style:dashed}.value__link:hover{text-decoration:underline}.description{overflow:hidden;text-overflow:ellipsis}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: TagModule }, { kind: "component", type: TagComponent, selector: "v-tag", inputs: ["color", "icon", "progress"] }, { kind: "directive", type: MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "component", type: MenuValueComponent, selector: "v-menu-value", inputs: ["value"] }, { kind: "component", type: ContentLoadingComponent, selector: "v-content-loading", inputs: ["width", "textSize", "hiddenText"] }, { kind: "directive", type: HighlightDirective, selector: "[vHighlight]", inputs: ["vHighlightText", "vHighlightSearch"] }, { kind: "component", type: ToggleValueComponent, selector: "v-toggle-value", inputs: ["value"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ValueComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-value', imports: [
+                        CommonModule,
+                        MatIcon,
+                        MatIconButton,
+                        TagModule,
+                        MatTooltip,
+                        MenuValueComponent,
+                        ContentLoadingComponent,
+                        HighlightDirective,
+                        ToggleValueComponent,
+                    ], host: {
+                        '[class.inline]': 'inline',
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, template: "@if (!value() && lazyValue() && !lazyVisible()) {\n    <button class=\"button\" mat-icon-button (click)=\"lazyVisible.set(true)\">\n        <mat-icon>sync</mat-icon>\n    </button>\n} @else {\n    @if (value$ | async; as v) {\n        <div\n            [ngClass]=\"{ wrapper__action: v.click || v.link }\"\n            class=\"wrapper\"\n            (click)=\"click($event)\"\n        >\n            @if (v.template) {\n                <ng-container *ngTemplateOutlet=\"v.template; context: {}\"></ng-container>\n            } @else {\n                @if (v.color) {\n                    <v-tag [color]=\"v.color\">\n                        <ng-container *ngTemplateOutlet=\"tooltipTemplate\"></ng-container>\n                    </v-tag>\n                } @else {\n                    <ng-container *ngTemplateOutlet=\"tooltipTemplate\"></ng-container>\n                }\n\n                <ng-template #tooltipTemplate>\n                    @if (v.tooltip) {\n                        <span [matTooltip]=\"v.tooltip\" class=\"tooltip\">\n                            <ng-container *ngTemplateOutlet=\"valueTemplate\"></ng-container>\n                        </span>\n                    } @else {\n                        <span [title]=\"v.value\">\n                            <ng-container *ngTemplateOutlet=\"valueTemplate\"></ng-container>\n                        </span>\n                    }\n                </ng-template>\n\n                <ng-template #valueTemplate>\n                    @switch (v.type) {\n                        @case ('menu') {\n                            <v-menu-value [value]=\"v\"></v-menu-value>\n                        }\n                        @case ('toggle') {\n                            <v-toggle-value [value]=\"v\"></v-toggle-value>\n                        }\n                        @default {\n                            @let valueText = valueText$ | async;\n                            @if (inProgress$ | async) {\n                                <v-content-loading [hiddenText]=\"valueText\"></v-content-loading>\n                            } @else if (valueText) {\n                                <span\n                                    [ngClass]=\"{ value__click: v.click, value__link: v.link }\"\n                                    [vHighlightSearch]=\"highlight\"\n                                    [vHighlightText]=\"valueText\"\n                                    vHighlight\n                                ></span>\n                            } @else if (emptySymbol) {\n                                <span style=\"color: #ccc\">{{ emptySymbol }}</span>\n                            }\n                        }\n                    }\n                </ng-template>\n            }\n\n            @if (v.description) {\n                <div\n                    [title]=\"v.description\"\n                    [vHighlightSearch]=\"highlight\"\n                    [vHighlightText]=\"v.description\"\n                    class=\"description mat-label-medium mat-secondary-text\"\n                    vHighlight\n                ></div>\n            }\n        </div>\n    } @else {\n        <v-content-loading></v-content-loading>\n    }\n}\n", styles: [":host{cursor:default;text-align:left}::ng-deep .inline,::ng-deep .inline *{white-space:nowrap}.tooltip{text-decoration:underline;text-decoration-style:dotted}.wrapper__action{cursor:pointer}.value__click:hover{text-decoration:underline;text-decoration-style:dashed}.value__link:hover{text-decoration:underline}.description{overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1$6.Router }], propDecorators: { inline: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], emptySymbol: [{
+                type: Input,
+                args: [{
+                        transform: (v) => (v === false ? '' : typeof v === 'string' ? v : '―'),
+                    }]
+            }], highlight: [{
+                type: Input
+            }] } });
+
+class ValueListComponent {
+    constructor() {
+        this.list = input();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ValueListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: ValueListComponent, isStandalone: true, selector: "v-value-list", inputs: { list: { classPropertyName: "list", publicName: "list", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+        @if (list(); as items) {
+            @if (items.length > 1) {
+                <div class="list">
+                    @for (item of items; track item) {
+                        <v-value [value]="item" inline></v-value>
+                    }
+                </div>
+            } @else {
+                <v-value [value]="items[0]" inline></v-value>
+            }
+        } @else {
+            <v-value [progress]="true" inline></v-value>
+        }
+    `, isInline: true, styles: [".list{display:flex;flex-direction:column}.list>*{overflow:hidden;text-overflow:ellipsis;min-height:20px}\n"], dependencies: [{ kind: "component", type: ValueComponent, selector: "v-value", inputs: ["value", "lazyValue", "lazyVisible", "progress", "inline", "emptySymbol", "highlight"], outputs: ["lazyVisibleChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ValueListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-value-list', imports: [ValueComponent], template: `
+        @if (list(); as items) {
+            @if (items.length > 1) {
+                <div class="list">
+                    @for (item of items; track item) {
+                        <v-value [value]="item" inline></v-value>
+                    }
+                </div>
+            } @else {
+                <v-value [value]="items[0]" inline></v-value>
+            }
+        } @else {
+            <v-value [progress]="true" inline></v-value>
+        }
+    `, styles: [".list{display:flex;flex-direction:column}.list>*{overflow:hidden;text-overflow:ellipsis;min-height:20px}\n"] }]
+        }] });
+
+class TableInputsComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableInputsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: TableInputsComponent, isStandalone: false, selector: "v-table-inputs", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableInputsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-table-inputs', template: `<ng-content></ng-content>`, changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, styles: [":host{display:block}\n"] }]
+        }] });
+
+function createUniqueColumnDef(name) {
+    return `___$$${typeof name === 'object' || isNil(name) ? 'column' : String(name)}_${Math.random().toString()}`;
+}
+
+const DEFAULT_SORT = { active: '', direction: '' };
+const DEBOUNCE_TIME_MS = 500;
+const DEFAULT_LOADED_LAZY_ROWS_COUNT = 3;
+const COLUMN_DEFS = {
+    select: createUniqueColumnDef('select'),
+    drag: createUniqueColumnDef('drag'),
+};
+
+function normalizePossiblyFn(fn) {
+    return typeof fn === 'function' ? fn : () => fn;
+}
+function normalizeCell(field, cell, hasChild = false) {
+    const cellFn = normalizePossiblyFn(cell);
+    return (...args) => getPossiblyAsyncObservable(cellFn(...args)).pipe(map((value) => {
+        const defaultValue = hasChild ? { value: '' } : { value: get(args[0], field) };
+        if (isNil(value)) {
+            return defaultValue;
+        }
+        return typeof value === 'object' ? { ...defaultValue, ...value } : { value };
+    }));
+}
+class NormColumn {
+    constructor({ field, header, cell, child, hidden, sort, lazyCell, ...params }, commonParams = {}) {
+        this.field = field ?? (typeof header === 'string' ? header : String(Math.random()));
+        const defaultHeaderValue = startCase((field || '').split('.').at(-1));
+        this.header = getPossiblyAsyncObservable(header).pipe(map((value) => typeof value === 'object'
+            ? { value: defaultHeaderValue, ...value }
+            : { value: value ?? defaultHeaderValue }));
+        if (cell || !lazyCell) {
+            this.cell = normalizeCell(this.field, cell, !!child);
+        }
+        if (lazyCell) {
+            this.lazyCell = normalizeCell(this.field, lazyCell, !!child);
+        }
+        if (child) {
+            this.child = normalizeCell(this.field, child);
+        }
+        this.params = {
+            ...commonParams,
+            ...params,
+            style: Object.assign({}, commonParams?.style, params?.style),
+        };
+        this.hidden = isNil(hidden) ? of(false) : getPossiblyAsyncObservable(hidden);
+        this.sort = isNil(sort) ? of(null) : getPossiblyAsyncObservable(sort);
+    }
+}
+
+function columnsDataToFilterSearchData(src$) {
+    const injector = inject(Injector);
+    return src$.pipe(map((data) => new Map(Array.from(data.entries()).map(([item, value]) => [
+        item,
+        {
+            byColumns: value.map((el) => [
+                runInInjectionContext(injector, () => normalizeString(valueToString(el?.value))),
+                normalizeString(String(el?.value?.description ?? '')),
+            ]),
+            byRow: JSON.stringify(item),
+        },
+    ]))));
+}
+function getWeight(searchValue, search, lowerCaseSearch, unimportance = 0) {
+    if (searchValue === search) {
+        return 1000000 - unimportance;
+    }
+    else if (searchValue.includes(search)) {
+        return 10000 - unimportance;
+    }
+    else if (searchValue.toLowerCase().includes(lowerCaseSearch)) {
+        return 100 - unimportance;
+    }
+    return 0;
+}
+function filterData(data, search) {
+    const lowerCaseSearch = search.toLowerCase();
+    return Array.from(data.entries())
+        .map(([value, searchValuesCols]) => ({
+        value,
+        priority: searchValuesCols.byColumns.reduce((priority, searchValues) => searchValues.reduce((colPriority, searchValue, idx) => colPriority + getWeight(searchValue, search, lowerCaseSearch, idx), priority), 0) + getWeight(searchValuesCols.byRow, search, lowerCaseSearch, 1),
+    }))
+        .filter((v) => v.priority)
+        .sort((a, b) => b.priority - a.priority)
+        .map((v) => v.value);
+}
+function sortData(source, data, columns, sort) {
+    if (!sort?.active || !sort?.direction) {
+        return source;
+    }
+    const colIdx = columns.findIndex((c) => c.field === sort.active);
+    const sortedData = source
+        .slice()
+        .sort((a, b) => compareDifferentTypes((data.get(a)?.byColumns ?? [])[colIdx]?.[0], (data.get(b)?.byColumns ?? [])[colIdx]?.[0]));
+    return sort.direction === 'desc' ? sortedData.reverse() : sortedData;
+}
+
+function treeDataItemToInlineDataItem(item) {
+    const children = item.children ?? [];
+    return [
+        children.length ? { value: item.value, child: children[0] } : { value: item.value },
+        ...children.slice(1).map((child) => ({ child })),
+    ];
+}
+
+function cachedHeadMap(fn) {
+    return (src$) => {
+        return src$.pipe(scan((acc, v) => {
+            return {
+                prev: v ?? [],
+                res: (v ?? []).map((el, idx) => acc.prev[idx] === el ? acc.res[idx] : fn(el, idx)),
+            };
+        }, { prev: [], res: [] }), map(({ res }) => res));
+    };
+}
+
+class TableDataSource extends MatTableDataSource {
+    get paginator() {
+        return this.__paginator;
+    }
+    constructor() {
+        super();
+        this.isTreeData$ = new BehaviorSubject(false);
+        this.sourceData$ = new BehaviorSubject([]);
+        this.data$ = this.isTreeData$.pipe(switchMap((isTreeData) => isTreeData
+            ? this.sourceData$.pipe(cachedHeadMap(treeDataItemToInlineDataItem), map((v) => v.flat()))
+            : this.sourceData$), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.__paginator = new OnePageTableDataSourcePaginator();
+        this.data$.pipe(takeUntilDestroyed(inject(DestroyRef))).subscribe((data) => {
+            this.data = data;
+        });
+    }
+    setData(data) {
+        this.sourceData$.next(data);
+        if (this.isTreeData$.value) {
+            this.isTreeData$.next(false);
+        }
+    }
+    setTreeData(data) {
+        this.sourceData$.next(data);
+        if (!this.isTreeData$.value) {
+            this.isTreeData$.next(true);
+        }
+    }
+}
+class OnePageTableDataSourcePaginator {
+    get length() {
+        return this.pageSize;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    set length(_length) { }
+    get displayedPages() {
+        return this.pageSize / this.partSize;
+    }
+    constructor(partSize) {
+        this.pageIndex = 0;
+        this.pageSize = 0;
+        this.page = new EventEmitter();
+        this.initialized = new BehaviorSubject(undefined);
+        this.setSize(partSize);
+    }
+    setSize(partSize = 25) {
+        if (partSize !== this.partSize) {
+            this.pageSize = this.partSize = partSize;
+            this.reload();
+        }
+    }
+    reload() {
+        this.pageSize = this.partSize;
+        this.update();
+    }
+    more() {
+        this.pageSize += this.partSize;
+        this.update();
+    }
+    update() {
+        this.page.next({
+            pageIndex: this.pageIndex,
+            pageSize: this.pageSize,
+            length: this.length,
+        });
+    }
+}
+
+function tableToCsvObject(cols, displayedData) {
+    const data = Array.from(displayedData.values()).map((columnData) => columnData.map((v) => v.value));
+    const res = [
+        cols
+            .map((v) => {
+            const res = valueToString(v);
+            return [res, `${res} (description)`];
+        })
+            .flat(),
+        ...data.map((r) => r.map((c) => [valueToString(c), unknownToString(c?.description)]).flat()),
+    ];
+    // Removing empty description columns (every second column)
+    let emptyCols = [];
+    for (let i = 1; i < res[0].length; i += 2 // description - every second column
+    ) {
+        let isEmpty = true;
+        for (let j = 1; // ignore header row
+         j < res.length; ++j) {
+            if (res[j][i]) {
+                isEmpty = false;
+                break;
+            }
+        }
+        if (isEmpty) {
+            emptyCols.push(i);
+        }
+    }
+    emptyCols = emptyCols.reverse();
+    for (const i of emptyCols) {
+        for (let j = 0; j < res.length; ++j) {
+            res[j].splice(i, 1);
+        }
+    }
+    return res;
+}
+
+function getValue(cellFn, ...[value, idx]) {
+    return cellFn ? cellFn(value, idx).pipe(toScannedValue) : of(null);
+}
+function toScannedValue(src$) {
+    return src$.pipe(shareReplay({
+        bufferSize: 1,
+        refCount: true,
+    }));
+}
+function toObservableColumnsData(src$) {
+    return src$.pipe(scan((acc, { isTree, data, cols }) => {
+        const isColsNotChanged = acc.cols === cols;
+        return {
+            res: new Map(isTree
+                ? data.map((d, idx) => [
+                    d,
+                    isColsNotChanged &&
+                        d === acc.data[idx] &&
+                        // This is not the last value, because we need to calculate isNextChild
+                        idx !== acc.data.length - 1
+                        ? acc.res.get(d)
+                        : new Map(cols.map((c) => [
+                            c,
+                            {
+                                value: d.child && c.child
+                                    ? getValue(c.child, d.child, idx)
+                                    : d.value
+                                        ? getValue(c.cell, d.value, idx)
+                                        : of({ value: '' }),
+                                // TODO add support of lazyValue
+                                isChild: !d.value,
+                                isNextChild: !data[idx + 1]?.value,
+                            },
+                        ])),
+                ])
+                : data.map((d, idx) => [
+                    d,
+                    isColsNotChanged && d === acc.data[idx]
+                        ? acc.res.get(d)
+                        : new Map(cols.map((c) => [
+                            c,
+                            {
+                                value: getValue(c.cell, d, idx),
+                                lazyValue: c.lazyCell
+                                    ? c.lazyCell(d, idx).pipe(toScannedValue)
+                                    : undefined,
+                            },
+                        ])),
+                ])),
+            data,
+            cols,
+        };
+    }, { data: [], cols: [], res: new Map() }), map(({ res }) => res));
+}
+function toColumnsData(src$) {
+    return src$.pipe(switchMap((columnsData) => {
+        if (!columnsData.size) {
+            return of(new Map());
+        }
+        return combineLatest(Array.from(columnsData.values()).map((v) => combineLatest(Array.from(v.values()).map((cell) => timer(0).pipe(switchMap(() => cell.value), distinctUntilChanged(isEqual$1)))).pipe(debounceTime(0)))).pipe(debounceTime(0), map((res) => new Map(Array.from(columnsData.entries()).map(([k, v], idx) => [
+            k,
+            Array.from(v.values()).map((cell, colIdx) => ({
+                ...cell,
+                value: res[idx][colIdx],
+            })),
+        ]))));
+    }));
+}
+
+class NoRecordsComponent {
+    constructor() {
+        this.noRecords = input(false, { transform: booleanAttribute });
+        this.progress = input(false, { transform: booleanAttribute });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NoRecordsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: NoRecordsComponent, isStandalone: true, selector: "v-no-records", inputs: { noRecords: { classPropertyName: "noRecords", publicName: "noRecords", isSignal: true, isRequired: false, transformFunction: null }, progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+        @if (noRecords()) {
+            <div class="no-records mat-body-large">
+                {{ progress() ? 'Loading...' : 'No records' }}
+            </div>
+        }
+    `, isInline: true, styles: [".no-records{position:absolute;z-index:999;top:calc(50% + 28px);left:50%;transform:translate(-50%) translateY(-50%)}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NoRecordsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-no-records', template: `
+        @if (noRecords()) {
+            <div class="no-records mat-body-large">
+                {{ progress() ? 'Loading...' : 'No records' }}
+            </div>
+        }
+    `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [], styles: [".no-records{position:absolute;z-index:999;top:calc(50% + 28px);left:50%;transform:translate(-50%) translateY(-50%)}\n"] }]
+        }] });
+
+function createIntersectionObserver(el) {
+    return new Observable((subscriber) => {
+        const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                if (entry.isIntersecting) {
+                    subscriber.next(entry);
+                }
+            }
+        });
+        observer.observe(el);
+        return {
+            unsubscribe() {
+                observer.disconnect();
+            },
+        };
+    });
+}
+
+class InfinityScrollDirective {
+    constructor(elementRef, dr) {
+        this.elementRef = elementRef;
+        this.dr = dr;
+        this.vInfinityScroll = input(false, { transform: booleanAttribute });
+        this.vInfinityScrollMore = output();
+    }
+    ngOnInit() {
+        createIntersectionObserver(this.elementRef.nativeElement)
+            .pipe(filter(() => this.vInfinityScroll()), takeUntilDestroyed(this.dr))
+            .subscribe(() => {
+            this.vInfinityScrollMore.emit();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InfinityScrollDirective, deps: [{ token: i0.ElementRef }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.2", type: InfinityScrollDirective, isStandalone: true, selector: "[vInfinityScroll]", inputs: { vInfinityScroll: { classPropertyName: "vInfinityScroll", publicName: "vInfinityScroll", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { vInfinityScrollMore: "vInfinityScrollMore" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InfinityScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vInfinityScroll]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.DestroyRef }] });
+
+class BaseColumnComponent {
+    constructor() {
+        this.name = input.required();
+        this.table = inject(MatTable);
+        this.columnDef = viewChild(MatColumnDef);
+        this.cellDef = viewChild(MatCellDef);
+        this.headerCellDef = viewChild(MatHeaderCellDef);
+        this.footerCellDef = viewChild(MatFooterCellDef);
+    }
+    ngOnInit() {
+        const columnDef = this.columnDef();
+        if (columnDef) {
+            columnDef.name = this.name();
+            columnDef.cell = this.cellDef();
+            columnDef.headerCell = this.headerCellDef();
+            columnDef.footerCell = this.footerCellDef();
+            this.removeColumnDef();
+            this.table.addColumnDef(columnDef);
+            this.addedColumnDef = columnDef;
+        }
+    }
+    ngOnDestroy() {
+        this.removeColumnDef();
+    }
+    removeColumnDef() {
+        if (this.table && this.addedColumnDef) {
+            this.table.removeColumnDef(this.addedColumnDef);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: BaseColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.2", type: BaseColumnComponent, isStandalone: true, inputs: { name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "columnDef", first: true, predicate: MatColumnDef, descendants: true, isSignal: true }, { propertyName: "cellDef", first: true, predicate: MatCellDef, descendants: true, isSignal: true }, { propertyName: "headerCellDef", first: true, predicate: MatHeaderCellDef, descendants: true, isSignal: true }, { propertyName: "footerCellDef", first: true, predicate: MatFooterCellDef, descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: BaseColumnComponent, decorators: [{
+            type: Directive
+        }] });
+
+class SelectColumnComponent extends BaseColumnComponent {
+    constructor(dr) {
+        super();
+        this.dr = dr;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.selected = model([]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.data = input([], { transform: arrayAttribute });
+        this.progress = input(false);
+        this.selection = new SelectionModel(true, []);
+        this.isAllSelected$ = combineLatest([
+            this.selection.changed.pipe(startWith(null)),
+            toObservable(this.data),
+        ]).pipe(map(() => this.getIsAllSelected()), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.selection.changed.pipe(takeUntilDestroyed(this.dr)).subscribe(() => {
+            this.selected.set(this.selection.selected);
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes.data || changes.selected) {
+            this.updateSelection();
+        }
+    }
+    toggleAllRows() {
+        if (this.getIsAllSelected()) {
+            this.selection.clear(true);
+            return;
+        }
+        this.selection.select(...this.data());
+    }
+    getIsAllSelected() {
+        const numSelected = this.selection.selected.length;
+        const numRows = this.data().length;
+        return numSelected === numRows;
+    }
+    updateSelection() {
+        const newSelected = (this.selected() || []).filter((d) => !!this.data()?.includes?.(d));
+        this.selection.deselect(...this.selection.selected.filter((s) => !newSelected.includes(s)));
+        this.selection.select(...newSelected);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectColumnComponent, deps: [{ token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.2", type: SelectColumnComponent, isStandalone: true, selector: "v-select-column", inputs: { selected: { classPropertyName: "selected", publicName: "selected", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selected: "selectedChange" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `
+        <ng-container [matColumnDef]="name()" [sticky]="true">
+            @let columnClasses = 'column';
+            <th *matHeaderCellDef [class]="columnClasses" mat-header-cell>
+                <mat-checkbox
+                    [checked]="selection.hasValue() && (isAllSelected$ | async)"
+                    [disabled]="!!progress() || !data()?.length"
+                    [indeterminate]="selection.hasValue() && !(isAllSelected$ | async)"
+                    (change)="$event ? toggleAllRows() : null"
+                >
+                </mat-checkbox>
+            </th>
+            <td *matCellDef="let row" [class]="columnClasses" mat-cell>
+                <mat-checkbox
+                    [checked]="selection.isSelected(row)"
+                    [disabled]="!!progress()"
+                    (change)="$event ? selection.toggle(row) : null"
+                    (click)="$event.stopPropagation()"
+                >
+                </mat-checkbox>
+            </td>
+            <td *matFooterCellDef [class]="columnClasses" mat-footer-cell>
+                <mat-checkbox disabled></mat-checkbox>
+            </td>
+        </ng-container>
+    `, isInline: true, styles: [".column{padding-left:4px;padding-right:4px;width:48px;border-right:1px solid;text-overflow:clip}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatTableModule }, { kind: "directive", type: i2$4.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i2$4.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i2$4.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i2$4.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i2$4.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i2$4.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i2$4.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "ngmodule", type: MatCheckboxModule }, { kind: "component", type: i3$1.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "aria-expanded", "aria-controls", "aria-owns", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "disabledInteractive", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-select-column', template: `
+        <ng-container [matColumnDef]="name()" [sticky]="true">
+            @let columnClasses = 'column';
+            <th *matHeaderCellDef [class]="columnClasses" mat-header-cell>
+                <mat-checkbox
+                    [checked]="selection.hasValue() && (isAllSelected$ | async)"
+                    [disabled]="!!progress() || !data()?.length"
+                    [indeterminate]="selection.hasValue() && !(isAllSelected$ | async)"
+                    (change)="$event ? toggleAllRows() : null"
+                >
+                </mat-checkbox>
+            </th>
+            <td *matCellDef="let row" [class]="columnClasses" mat-cell>
+                <mat-checkbox
+                    [checked]="selection.isSelected(row)"
+                    [disabled]="!!progress()"
+                    (change)="$event ? selection.toggle(row) : null"
+                    (click)="$event.stopPropagation()"
+                >
+                </mat-checkbox>
+            </td>
+            <td *matFooterCellDef [class]="columnClasses" mat-footer-cell>
+                <mat-checkbox disabled></mat-checkbox>
+            </td>
+        </ng-container>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule, MatTableModule, MatCheckboxModule], styles: [".column{padding-left:4px;padding-right:4px;width:48px;border-right:1px solid;text-overflow:clip}\n"] }]
+        }], ctorParameters: () => [{ type: i0.DestroyRef }] });
+
+class DndColumnComponent extends BaseColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.dragged = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DndColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: DndColumnComponent, isStandalone: true, selector: "v-dnd-column", outputs: { dragged: "dragged" }, usesInheritance: true, ngImport: i0, template: `
+        <ng-container [matColumnDef]="name()" [sticky]="true">
+            @let columnClasses = 'column';
+            <th *matHeaderCellDef [class]="columnClasses" mat-header-cell></th>
+            <td *matCellDef="let row" [class]="columnClasses" mat-cell>
+                <div class="position">
+                    <mat-icon class="dragCursor" (mousedown)="dragged.emit()">reorder</mat-icon>
+                    <!-- <span>{{ index + 1 }}</span>-->
+                </div>
+            </td>
+            <td *matFooterCellDef [class]="columnClasses" mat-footer-cell>
+                <div class="position">
+                    <mat-icon class="dragCursor">reorder</mat-icon>
+                </div>
+            </td>
+        </ng-container>
+    `, isInline: true, styles: [".column .position{display:flex;align-items:center;gap:8px}.column .position .dragCursor{cursor:move}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatTableModule }, { kind: "directive", type: i2$4.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i2$4.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i2$4.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i2$4.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i2$4.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i2$4.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i2$4.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DndColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-dnd-column', template: `
+        <ng-container [matColumnDef]="name()" [sticky]="true">
+            @let columnClasses = 'column';
+            <th *matHeaderCellDef [class]="columnClasses" mat-header-cell></th>
+            <td *matCellDef="let row" [class]="columnClasses" mat-cell>
+                <div class="position">
+                    <mat-icon class="dragCursor" (mousedown)="dragged.emit()">reorder</mat-icon>
+                    <!-- <span>{{ index + 1 }}</span>-->
+                </div>
+            </td>
+            <td *matFooterCellDef [class]="columnClasses" mat-footer-cell>
+                <div class="position">
+                    <mat-icon class="dragCursor">reorder</mat-icon>
+                </div>
+            </td>
+        </ng-container>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule, MatTableModule, MatIconModule], styles: [".column .position{display:flex;align-items:center;gap:8px}.column .position .dragCursor{cursor:move}\n"] }]
+        }] });
+
+class TableInfoBarComponent {
+    constructor(dr) {
+        this.dr = dr;
+        this.progress = input(false, { transform: booleanAttribute });
+        this.hasMore = input(false, { transform: booleanAttribute });
+        this.hasLoad = input(false, { transform: booleanAttribute });
+        this.isPreload = input(false, { transform: booleanAttribute });
+        this.noDownload = input(false, { transform: booleanAttribute });
+        this.noToolbar = input(false, { transform: booleanAttribute });
+        this.dataProgress = input(false, { transform: booleanAttribute });
+        this.columns = input([]);
+        this.size = input(0, { transform: numberAttribute });
+        this.preloadSize = input(0, { transform: numberAttribute });
+        this.count = input(undefined);
+        this.filteredCount = input(0);
+        this.selectedCount = input(0);
+        this.filter = input('');
+        this.standaloneFilter = input(false, { transform: booleanAttribute });
+        this.hasInputs = input(false, { transform: booleanAttribute });
+        this.filterChange = output();
+        this.filterControl = new FormControl('', { nonNullable: true });
+        this.downloadCsv = output();
+        // eslint-disable-next-line @angular-eslint/no-output-native
+        this.load = output();
+        this.preload = output();
+        this.countText = computed(() => this.count()
+            ? (this.filter() && this.filteredCount() !== this.count()
+                ? this.filteredCount() + '/'
+                : '') +
+                (this.hasMore() ? '>' : '') +
+                this.count()
+            : this.progress() || this.count() !== 0
+                ? '...'
+                : '0');
+    }
+    ngOnInit() {
+        this.filterControl.valueChanges.pipe(takeUntilDestroyed(this.dr)).subscribe((v) => {
+            this.filterChange.emit(v);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableInfoBarComponent, deps: [{ token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: TableInfoBarComponent, isStandalone: false, selector: "v-table-info-bar", inputs: { progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null }, hasMore: { classPropertyName: "hasMore", publicName: "hasMore", isSignal: true, isRequired: false, transformFunction: null }, hasLoad: { classPropertyName: "hasLoad", publicName: "hasLoad", isSignal: true, isRequired: false, transformFunction: null }, isPreload: { classPropertyName: "isPreload", publicName: "isPreload", isSignal: true, isRequired: false, transformFunction: null }, noDownload: { classPropertyName: "noDownload", publicName: "noDownload", isSignal: true, isRequired: false, transformFunction: null }, noToolbar: { classPropertyName: "noToolbar", publicName: "noToolbar", isSignal: true, isRequired: false, transformFunction: null }, dataProgress: { classPropertyName: "dataProgress", publicName: "dataProgress", isSignal: true, isRequired: false, transformFunction: null }, columns: { classPropertyName: "columns", publicName: "columns", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, preloadSize: { classPropertyName: "preloadSize", publicName: "preloadSize", isSignal: true, isRequired: false, transformFunction: null }, count: { classPropertyName: "count", publicName: "count", isSignal: true, isRequired: false, transformFunction: null }, filteredCount: { classPropertyName: "filteredCount", publicName: "filteredCount", isSignal: true, isRequired: false, transformFunction: null }, selectedCount: { classPropertyName: "selectedCount", publicName: "selectedCount", isSignal: true, isRequired: false, transformFunction: null }, filter: { classPropertyName: "filter", publicName: "filter", isSignal: true, isRequired: false, transformFunction: null }, standaloneFilter: { classPropertyName: "standaloneFilter", publicName: "standaloneFilter", isSignal: true, isRequired: false, transformFunction: null }, hasInputs: { classPropertyName: "hasInputs", publicName: "hasInputs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { filterChange: "filterChange", downloadCsv: "downloadCsv", load: "load", preload: "preload" }, ngImport: i0, template: "<div class=\"wrapper\">\n    @if (standaloneFilter()) {\n        <div class=\"header-wrapper\">\n            @if (hasInputs()) {\n                <ng-content select=\"v-table-inputs\"></ng-content>\n            }\n            <v-input-field\n                [formControl]=\"filterControl\"\n                class=\"filter__standalone filter\"\n                cleanButton\n                label=\"Search\"\n            ></v-input-field>\n        </div>\n    }\n    <v-actions>\n        <v-actions>\n            @if (!noToolbar()) {\n                @if (!standaloneFilter()) {\n                    <div>\n                        <v-input-field\n                            [formControl]=\"filterControl\"\n                            appearance=\"outline\"\n                            class=\"filter filter__extended\"\n                            cleanButton\n                            icon=\"manage_search\"\n                            label=\"Search\"\n                            size=\"small\"\n                        ></v-input-field>\n                    </div>\n                }\n                <div class=\"details\">\n                    @if (hasLoad() || hasMore()) {\n                        <button\n                            [disabled]=\"progress() || !hasMore()\"\n                            mat-icon-button\n                            matTooltip=\"Preload {{ preloadSize() }}{{\n                                isPreload() && hasMore() ? ' more' : ''\n                            }} elements\"\n                            (click)=\"preload.emit()\"\n                        >\n                            <mat-icon>\n                                {{\n                                    hasMore()\n                                        ? isPreload()\n                                            ? 'downloading'\n                                            : 'download'\n                                        : 'download_done'\n                                }}\n                            </mat-icon>\n                        </button>\n                    }\n                    @if (!noDownload()) {\n                        <button\n                            [disabled]=\"progress() || !count()\"\n                            mat-icon-button\n                            matTooltip=\"Download CSV\"\n                            (click)=\"downloadCsv.emit()\"\n                        >\n                            <mat-icon>file_save</mat-icon>\n                        </button>\n                    }\n                    <!-- <button mat-icon-button matTooltip=\"Customize table\" (click)=\"tune()\">\n                        <mat-icon>tune</mat-icon>\n                    </button> -->\n                </div>\n            }\n            <div\n                [matBadge]=\"selectedCount() || ''\"\n                [matBadgeDisabled]=\"progress() || dataProgress()\"\n                [matTooltip]=\"\n                    dataProgress()\n                        ? 'Preparing data for sorting, filtering and downloading...'\n                        : progress()\n                          ? 'Loading...'\n                          : 'Reload ' + size() + ' elements'\n                \"\n                class=\"count\"\n                (click)=\"hasLoad() ? load.emit() : undefined\"\n            >\n                <v-tag\n                    [icon]=\"hasLoad() ? 'refresh' : undefined\"\n                    [progress]=\"progress() || dataProgress()\"\n                >\n                    {{ countText() }}\n                </v-tag>\n            </div>\n        </v-actions>\n        <v-actions>\n            <ng-content></ng-content>\n        </v-actions>\n    </v-actions>\n</div>\n", styles: [".wrapper{display:flex;flex-direction:column;gap:8px}.inputs{display:none}.inputs:not(:empty){display:block}.header-wrapper{display:flex;gap:16px}::ng-deep .header-wrapper>*{flex:1}.details{display:flex;align-items:center}.details ::ng-deep button{margin:-6px 0}.count{align-self:anchor-center}.filter__extended{max-width:200px}.filter ::ng-deep .mat-mdc-form-field-subscript-wrapper{height:0}\n"], dependencies: [{ kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i2$5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "component", type: i1$4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: InputFieldComponent, selector: "v-input-field", inputs: ["label", "placeholder", "type", "appearance", "size", "cleanButton", "icon"] }, { kind: "component", type: ActionsComponent, selector: "v-actions" }, { kind: "directive", type: i6.MatBadge, selector: "[matBadge]", inputs: ["matBadgeColor", "matBadgeOverlap", "matBadgeDisabled", "matBadgePosition", "matBadge", "matBadgeDescription", "matBadgeSize", "matBadgeHidden"] }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: TagComponent, selector: "v-tag", inputs: ["color", "icon", "progress"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableInfoBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-table-info-bar', standalone: false, template: "<div class=\"wrapper\">\n    @if (standaloneFilter()) {\n        <div class=\"header-wrapper\">\n            @if (hasInputs()) {\n                <ng-content select=\"v-table-inputs\"></ng-content>\n            }\n            <v-input-field\n                [formControl]=\"filterControl\"\n                class=\"filter__standalone filter\"\n                cleanButton\n                label=\"Search\"\n            ></v-input-field>\n        </div>\n    }\n    <v-actions>\n        <v-actions>\n            @if (!noToolbar()) {\n                @if (!standaloneFilter()) {\n                    <div>\n                        <v-input-field\n                            [formControl]=\"filterControl\"\n                            appearance=\"outline\"\n                            class=\"filter filter__extended\"\n                            cleanButton\n                            icon=\"manage_search\"\n                            label=\"Search\"\n                            size=\"small\"\n                        ></v-input-field>\n                    </div>\n                }\n                <div class=\"details\">\n                    @if (hasLoad() || hasMore()) {\n                        <button\n                            [disabled]=\"progress() || !hasMore()\"\n                            mat-icon-button\n                            matTooltip=\"Preload {{ preloadSize() }}{{\n                                isPreload() && hasMore() ? ' more' : ''\n                            }} elements\"\n                            (click)=\"preload.emit()\"\n                        >\n                            <mat-icon>\n                                {{\n                                    hasMore()\n                                        ? isPreload()\n                                            ? 'downloading'\n                                            : 'download'\n                                        : 'download_done'\n                                }}\n                            </mat-icon>\n                        </button>\n                    }\n                    @if (!noDownload()) {\n                        <button\n                            [disabled]=\"progress() || !count()\"\n                            mat-icon-button\n                            matTooltip=\"Download CSV\"\n                            (click)=\"downloadCsv.emit()\"\n                        >\n                            <mat-icon>file_save</mat-icon>\n                        </button>\n                    }\n                    <!-- <button mat-icon-button matTooltip=\"Customize table\" (click)=\"tune()\">\n                        <mat-icon>tune</mat-icon>\n                    </button> -->\n                </div>\n            }\n            <div\n                [matBadge]=\"selectedCount() || ''\"\n                [matBadgeDisabled]=\"progress() || dataProgress()\"\n                [matTooltip]=\"\n                    dataProgress()\n                        ? 'Preparing data for sorting, filtering and downloading...'\n                        : progress()\n                          ? 'Loading...'\n                          : 'Reload ' + size() + ' elements'\n                \"\n                class=\"count\"\n                (click)=\"hasLoad() ? load.emit() : undefined\"\n            >\n                <v-tag\n                    [icon]=\"hasLoad() ? 'refresh' : undefined\"\n                    [progress]=\"progress() || dataProgress()\"\n                >\n                    {{ countText() }}\n                </v-tag>\n            </div>\n        </v-actions>\n        <v-actions>\n            <ng-content></ng-content>\n        </v-actions>\n    </v-actions>\n</div>\n", styles: [".wrapper{display:flex;flex-direction:column;gap:8px}.inputs{display:none}.inputs:not(:empty){display:block}.header-wrapper{display:flex;gap:16px}::ng-deep .header-wrapper>*{flex:1}.details{display:flex;align-items:center}.details ::ng-deep button{margin:-6px 0}.count{align-self:anchor-center}.filter__extended{max-width:200px}.filter ::ng-deep .mat-mdc-form-field-subscript-wrapper{height:0}\n"] }]
+        }], ctorParameters: () => [{ type: i0.DestroyRef }] });
+
+class TableComponent {
+    constructor(dr, injector, cdr) {
+        this.dr = dr;
+        this.injector = injector;
+        this.cdr = cdr;
+        this.data = input([], { transform: arrayAttribute });
+        this.treeData = input();
+        this.columns = input([], {
+            transform: arrayAttribute,
+        });
+        this.progress = input(false, { transform: Boolean });
+        this.hasMore = input(false, { transform: booleanAttribute });
+        this.size = input(25, { transform: numberAttribute });
+        this.maxSize = input(1000, { transform: numberAttribute });
+        this.noDownload = input(false, { transform: booleanAttribute });
+        this.noToolbar = input(false, { transform: booleanAttribute });
+        // Filter
+        this.filter = model('');
+        this.filter$ = toObservable(this.filter).pipe(map((v) => (v || '').trim()), distinctUntilChanged(), debounceTime$1(DEBOUNCE_TIME_MS), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.standaloneFilter = input(false, { transform: booleanAttribute });
+        this.externalFilter = input(false, { transform: booleanAttribute });
+        this.filteredSortData$ = new BehaviorSubject(null);
+        this.displayedData$ = combineLatest([
+            defer(() => this.dataSource.data$),
+            this.filteredSortData$.pipe(distinctUntilChanged()),
+            defer(() => this.columnsDataProgress$),
+        ]).pipe(map(([data, filteredSortData, columnsDataProgress]) => (filteredSortData && !columnsDataProgress ? filteredSortData : data) || []), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.displayedCount$ = this.displayedData$.pipe(map((data) => data.length), distinctUntilChanged(), shareReplay({ refCount: true, bufferSize: 1 }));
+        // Select
+        this.rowSelectable = input(false, { transform: booleanAttribute });
+        this.rowSelected = model([]);
+        // Sort
+        this.sort = model(DEFAULT_SORT);
+        // Drag & drop
+        this.rowDragDrop = input(false, {
+            transform: (v) => {
+                if (Array.isArray(v)) {
+                    return v;
+                }
+                return booleanAttribute(v);
+            },
+        });
+        this.rowDropped = output();
+        this.dragDisabled = true;
+        this.update$ = new Subject();
+        this.update = outputFromObservable(this.update$);
+        this.more = output();
+        this.loadedLazyItems = new WeakMap();
+        this.dataSource = new TableDataSource();
+        this.normColumns = computed(() => this.columns().map((c) => new NormColumn(c)));
+        this.displayedNormColumns$ = toObservable(this.normColumns).pipe(switchMap((cols) => combineLatest(cols.map((c) => c.hidden)).pipe(map((c) => cols.filter((_, idx) => !c[idx])))), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.columnsData$$ = combineLatest({
+            isTree: this.dataSource.isTreeData$,
+            data: this.dataSource.data$,
+            cols: toObservable(this.normColumns),
+        }).pipe(toObservableColumnsData, shareReplay({ refCount: true, bufferSize: 1 }));
+        this.columnsDataProgress$ = new BehaviorSubject(false);
+        this.columnsData$ = this.columnsData$$.pipe(tap(() => {
+            this.columnsDataProgress$.next(true);
+        }), toColumnsData, tap(() => {
+            this.columnsDataProgress$.next(false);
+        }), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.isPreload = signal(false);
+        this.loadSize = computed(() => (this.isPreload() ? this.maxSize() : this.size()));
+        this.hasAutoShowMore$ = combineLatest([
+            toObservable(this.hasMore),
+            this.dataSource.data$.pipe(map((d) => d?.length)),
+            this.displayedCount$,
+            this.dataSource.paginator.page.pipe(startWith(null), map(() => this.dataSource.paginator.pageSize)),
+        ]).pipe(map(([hasMore, dataCount, displayedDataCount, size]) => (hasMore && displayedDataCount !== 0 && displayedDataCount >= dataCount) ||
+            displayedDataCount > size), distinctUntilChanged(), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.displayedColumns$ = combineLatest([
+            this.displayedNormColumns$,
+            toObservable(this.rowSelectable),
+            toObservable(this.sort),
+            toObservable(this.rowDragDrop),
+        ]).pipe(map(([normColumns, rowSelectable, sort, rowDragDrop]) => [
+            ...((Array.isArray(rowDragDrop)
+                ? sort?.direction && rowDragDrop.includes(sort?.active)
+                : rowDragDrop)
+                ? [this.columnDefs.drag]
+                : []),
+            ...(rowSelectable ? [this.columnDefs.select] : []),
+            ...normColumns.map((c) => c.field),
+        ]), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.columnDefs = COLUMN_DEFS;
+    }
+    ngOnInit() {
+        const sort$ = toObservable(this.sort, { injector: this.injector }).pipe(distinctUntilChanged(), share());
+        toObservable(this.data, { injector: this.injector })
+            .pipe(filter(Boolean), takeUntilDestroyed(this.dr))
+            .subscribe((data) => {
+            this.dataSource.setData(data);
+        });
+        toObservable(this.treeData, { injector: this.injector })
+            .pipe(filter(Boolean), takeUntilDestroyed(this.dr))
+            .subscribe((data) => {
+            this.dataSource.setTreeData(data);
+        });
+        combineLatest([
+            this.filter$,
+            sort$,
+            this.dataSource.data$,
+            runInInjectionContext(this.injector, () => this.columnsData$.pipe(columnsDataToFilterSearchData)),
+            this.dataSource.isTreeData$,
+            toObservable(this.normColumns, { injector: this.injector }),
+            toObservable(this.externalFilter, { injector: this.injector }),
+        ])
+            .pipe(map(([search, sort, source, data, isTreeData, columns, isExternalFilter]) => {
+            if (isTreeData) {
+                return source;
+            }
+            const filteredData = !isExternalFilter && search ? filterData(data, search) : source;
+            return sortData(filteredData, data, columns, sort);
+        }), takeUntilDestroyed(this.dr))
+            .subscribe((filtered) => {
+            this.updateSortFilter(filtered);
+            this.updateLoadedLazyItems(filtered);
+            this.cdr.markForCheck();
+        });
+        merge(this.filter$.pipe(filter(Boolean)), toObservable(this.hasMore, { injector: this.injector }).pipe(filter(Boolean)))
+            .pipe(takeUntilDestroyed(this.dr))
+            .subscribe(() => {
+            this.sort.set(DEFAULT_SORT);
+        });
+        merge(this.filter$, sort$)
+            .pipe(takeUntilDestroyed(this.dr))
+            .subscribe(() => {
+            this.reset();
+        });
+        // TODO: 2, 3 column is torn away from the previous one, fixed by calling update
+        this.dataSource.data$
+            .pipe(filter((v) => !!v?.length), first$1(), delay(100), takeUntilDestroyed(this.dr))
+            .subscribe(() => {
+            this.table.updateStickyColumnStyles();
+        });
+    }
+    load() {
+        if (this.isPreload()) {
+            this.isPreload.set(false);
+        }
+        this.reload();
+    }
+    preload() {
+        if (!this.isPreload()) {
+            this.isPreload.set(true);
+            this.reload();
+        }
+        else if (this.hasMore()) {
+            this.more.emit({ size: this.loadSize() });
+        }
+    }
+    showMore() {
+        this.dataSource.paginator.more();
+        if (this.hasMore() && this.dataSource.paginator.pageSize > this.dataSource.data.length) {
+            this.more.emit({ size: this.loadSize() });
+        }
+        this.refreshTable();
+    }
+    downloadCsv() {
+        this.generateCsvData()
+            .pipe(takeUntilDestroyed(this.dr))
+            .subscribe((csvData) => {
+            downloadFile(csvData, 'csv');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    drop(event) {
+        this.dragDisabled = true;
+        this.filteredSortData$.pipe(filter(Boolean), first$1()).subscribe((data) => {
+            const item = event.item.data;
+            const { previousIndex, currentIndex } = event;
+            const previousData = data;
+            const currentData = previousData.slice();
+            let currentDataIndex = 0;
+            if (previousIndex > currentIndex) {
+                currentData.splice(previousIndex, 1);
+                currentData.splice(currentIndex, 0, event.item.data);
+                currentDataIndex = currentIndex;
+            }
+            else {
+                currentData.splice(currentIndex, 0, event.item.data);
+                currentData.splice(previousIndex, 1);
+                currentDataIndex = currentIndex - 1;
+            }
+            this.rowDropped.emit({
+                previousIndex,
+                currentIndex,
+                item,
+                previousData,
+                currentData,
+                currentDataIndex,
+                sort: this?.sortComponent,
+            });
+        });
+    }
+    generateCsvData() {
+        return combineLatest([
+            this.displayedNormColumns$.pipe(switchMap((cols) => forkJoin(cols.map((c) => c.header.pipe(take(1)))))),
+            this.columnsData$.pipe(take(1)),
+        ]).pipe(map(([cols, data]) => createCsv(runInInjectionContext(this.injector, () => tableToCsvObject(cols, data)))));
+    }
+    reload() {
+        this.update$.next({ size: this.loadSize() });
+        this.reset();
+    }
+    updateSortFilter(filtered) {
+        this.filteredSortData$.next(filtered);
+        this.dataSource.sortData = () => filtered;
+        this.dataSource.sort = this.sortComponent;
+    }
+    reset() {
+        this.scrollViewport?.nativeElement?.scrollTo?.({ top: 0 });
+        this.dataSource.paginator.reload();
+        this.refreshTable();
+    }
+    // TODO: Refresh table when pagination is updated
+    refreshTable() {
+        // eslint-disable-next-line no-self-assign
+        this.dataSource.data = this.dataSource.data;
+    }
+    updateLoadedLazyItems(items) {
+        const lazyLoadedItems = items.slice(0, DEFAULT_LOADED_LAZY_ROWS_COUNT);
+        for (const item of lazyLoadedItems) {
+            this.loadedLazyItems.set(item, true);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableComponent, deps: [{ token: i0.DestroyRef }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: TableComponent, isStandalone: false, selector: "v-table", inputs: { data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, treeData: { classPropertyName: "treeData", publicName: "treeData", isSignal: true, isRequired: false, transformFunction: null }, columns: { classPropertyName: "columns", publicName: "columns", isSignal: true, isRequired: false, transformFunction: null }, progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null }, hasMore: { classPropertyName: "hasMore", publicName: "hasMore", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, maxSize: { classPropertyName: "maxSize", publicName: "maxSize", isSignal: true, isRequired: false, transformFunction: null }, noDownload: { classPropertyName: "noDownload", publicName: "noDownload", isSignal: true, isRequired: false, transformFunction: null }, noToolbar: { classPropertyName: "noToolbar", publicName: "noToolbar", isSignal: true, isRequired: false, transformFunction: null }, filter: { classPropertyName: "filter", publicName: "filter", isSignal: true, isRequired: false, transformFunction: null }, standaloneFilter: { classPropertyName: "standaloneFilter", publicName: "standaloneFilter", isSignal: true, isRequired: false, transformFunction: null }, externalFilter: { classPropertyName: "externalFilter", publicName: "externalFilter", isSignal: true, isRequired: false, transformFunction: null }, rowSelectable: { classPropertyName: "rowSelectable", publicName: "rowSelectable", isSignal: true, isRequired: false, transformFunction: null }, rowSelected: { classPropertyName: "rowSelected", publicName: "rowSelected", isSignal: true, isRequired: false, transformFunction: null }, sort: { classPropertyName: "sort", publicName: "sort", isSignal: true, isRequired: false, transformFunction: null }, rowDragDrop: { classPropertyName: "rowDragDrop", publicName: "rowDragDrop", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { filter: "filterChange", rowSelected: "rowSelectedChange", sort: "sortChange", rowDropped: "rowDropped", update: "update", more: "more" }, queries: [{ propertyName: "tableInputsContent", first: true, predicate: TableInputsComponent, descendants: true, read: ElementRef }], viewQueries: [{ propertyName: "sortComponent", first: true, predicate: MatSort, descendants: true }, { propertyName: "scrollViewport", first: true, predicate: ["scrollViewport"], descendants: true, read: ElementRef }, { propertyName: "table", first: true, predicate: ["matTable"], descendants: true }, { propertyName: "tableRow", first: true, predicate: MatRow, descendants: true }], ngImport: i0, template: "@let columnsData = columnsData$$ | async;\n\n<div class=\"wrapper\">\n    <v-table-info-bar\n        [(filter)]=\"filter\"\n        [columns]=\"normColumns()\"\n        [count]=\"(dataSource.data$ | async)?.length\"\n        [dataProgress]=\"!!(columnsDataProgress$ | async) && !hasMore()\"\n        [filteredCount]=\"displayedCount$ | async\"\n        [hasInputs]=\"!!tableInputsContent?.nativeElement\"\n        [hasLoad]=\"update$.observed\"\n        [hasMore]=\"hasMore()\"\n        [isPreload]=\"isPreload()\"\n        [noDownload]=\"noDownload()\"\n        [noToolbar]=\"noToolbar()\"\n        [preloadSize]=\"maxSize()\"\n        [progress]=\"progress()\"\n        [selectedCount]=\"rowSelected()?.length\"\n        [size]=\"size()\"\n        [standaloneFilter]=\"standaloneFilter()\"\n        (downloadCsv)=\"downloadCsv()\"\n        (load)=\"load()\"\n        (preload)=\"preload()\"\n    >\n        <ng-content select=\"v-table-actions\"></ng-content>\n        <v-table-inputs><ng-content select=\"v-table-inputs\"></ng-content></v-table-inputs>\n    </v-table-info-bar>\n    <mat-card #scrollViewport class=\"card\">\n        <v-no-records\n            [noRecords]=\"!(displayedCount$ | async)\"\n            [progress]=\"progress()\"\n        ></v-no-records>\n        <table\n            #matTable\n            [cdkDropListDisabled]=\"dragDisabled\"\n            [dataSource]=\"dataSource\"\n            [matSortActive]=\"(columnsDataProgress$ | async) || progress() ? '' : sort().active\"\n            [matSortDirection]=\"sort().direction\"\n            cdkDropList\n            cdkDropListData=\"dataSource\"\n            mat-table\n            matSort\n            (cdkDropListDropped)=\"drop($event)\"\n            (matSortChange)=\"sort.set($event)\"\n        >\n            @let displayedColumns = (displayedColumns$ | async) || [];\n\n            @if (displayedColumns.includes(columnDefs.drag)) {\n                <v-dnd-column\n                    [name]=\"columnDefs.drag\"\n                    (dragged)=\"dragDisabled = false\"\n                ></v-dnd-column>\n            }\n            @if (displayedColumns.includes(columnDefs.select)) {\n                <v-select-column\n                    [(selected)]=\"rowSelected\"\n                    [data]=\"displayedData$ | async\"\n                    [name]=\"columnDefs.select\"\n                    [progress]=\"progress()\"\n                ></v-select-column>\n            }\n            @for (col of displayedNormColumns$ | async; track col; let colIndex = $index) {\n                @let stickyStart = col.params.sticky === 'start';\n                @let stickyEnd = col.params.sticky === 'end';\n                @let columnClasses =\n                    {\n                        column: true,\n                        'column__sticky-start': stickyStart,\n                        'column__sticky-end': stickyEnd,\n                    };\n                <ng-container\n                    [matColumnDef]=\"col.field\"\n                    [sticky]=\"stickyStart\"\n                    [stickyEnd]=\"stickyEnd\"\n                >\n                    <th\n                        *matHeaderCellDef\n                        [disabled]=\"(col.sort | async) === false || hasMore() || progress()\"\n                        [mat-sort-header]=\"col.field\"\n                        [ngClass]=\"columnClasses\"\n                        mat-header-cell\n                    >\n                        <v-value [value]=\"col?.header | async\" emptySymbol=\"\" inline></v-value>\n                    </th>\n\n                    <ng-template let-element let-rowIndex=\"index\" matCellDef>\n                        @let cell = columnsData?.get?.(element)?.get(col);\n                        <td\n                            [ngClass]=\"columnClasses\"\n                            [ngStyle]=\"col?.params?.style\"\n                            [style.border-bottom]=\"cell?.isNextChild && !col.child ? 'none' : ''\"\n                            mat-cell\n                        >\n                            <v-value\n                                [emptySymbol]=\"!(cell?.isChild && !col?.child)\"\n                                [highlight]=\"filter$ | async\"\n                                [lazyValue]=\"cell?.lazyValue\"\n                                [lazyVisible]=\"loadedLazyItems.has(element)\"\n                                [value]=\"cell?.value | async\"\n                                inline\n                                (lazyVisibleChange)=\"loadedLazyItems.set(element, true)\"\n                            ></v-value>\n                        </td>\n                    </ng-template>\n                    <td *matFooterCellDef [ngClass]=\"columnClasses\" mat-footer-cell>\n                        <v-content-loading></v-content-loading>\n                    </td>\n                </ng-container>\n            }\n\n            <tr *matHeaderRowDef=\"displayedColumns$ | async; sticky: true\" mat-header-row></tr>\n            <tr\n                *matRowDef=\"let row; columns: displayedColumns$ | async\"\n                [cdkDragData]=\"row\"\n                cdkDrag\n                mat-row\n            ></tr>\n            <tr\n                *matFooterRowDef=\"displayedColumns$ | async\"\n                [ngClass]=\"{ row__hidden: !(hasAutoShowMore$ | async) || !tableRow }\"\n                [vInfinityScroll]=\"!progress()\"\n                mat-footer-row\n                (vInfinityScrollMore)=\"showMore()\"\n            ></tr>\n        </table>\n    </mat-card>\n</div>\n", styles: [":host{min-height:0}.wrapper{display:grid;grid-template-columns:1fr;grid-template-rows:max-content;gap:24px;height:100%}.wrapper .card{width:100%;height:100%;min-height:300px;overflow:auto;transform:translateZ(0)}.wrapper .card ::ng-deep .mdc-data-table__row:last-child .mat-mdc-cell{border-bottom-color:var(--mat-table-row-item-outline-color, rgba(0, 0, 0, .12))!important;border-bottom-width:var(--mat-table-row-item-outline-width, 1px)!important;border-bottom-style:solid!important}table ::ng-deep .cdk-drag-placeholder,::ng-deep .cdk-drag-preview ::ng-deep .cdk-drag-placeholder{background:#eee}table .column,::ng-deep .cdk-drag-preview .column{max-width:max(20px,30vw)}table .column__sticky-start,table .column__sticky-end,::ng-deep .cdk-drag-preview .column__sticky-start,::ng-deep .cdk-drag-preview .column__sticky-end{width:0}table .column__sticky-start,::ng-deep .cdk-drag-preview .column__sticky-start{border-right:1px solid}table .column__sticky-end,::ng-deep .cdk-drag-preview .column__sticky-end{border-left:1px solid}table .row__hidden,::ng-deep .cdk-drag-preview .row__hidden{display:none}::ng-deep .cdk-drag-preview{box-sizing:border-box;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f;background:#fff!important;display:flex!important;align-items:center}::ng-deep .cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}::ng-deep .cdk-drop-list-dragging ::ng-deep .mat-mdc-row:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}::ng-deep .cdk-drag-preview ::ng-deep td{border:none!important}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i2$4.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i2$4.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i2$4.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i2$4.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i2$4.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i2$4.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i2$4.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i2$4.MatFooterRowDef, selector: "[matFooterRowDef]", inputs: ["matFooterRowDef", "matFooterRowDefSticky"] }, { kind: "directive", type: i2$4.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i2$4.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i2$4.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "component", type: i2$4.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i2$4.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "component", type: i2$4.MatFooterRow, selector: "mat-footer-row, tr[mat-footer-row]", exportAs: ["matFooterRow"] }, { kind: "component", type: i4.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "component", type: ValueComponent, selector: "v-value", inputs: ["value", "lazyValue", "lazyVisible", "progress", "inline", "emptySymbol", "highlight"], outputs: ["lazyVisibleChange"] }, { kind: "component", type: NoRecordsComponent, selector: "v-no-records", inputs: ["noRecords", "progress"] }, { kind: "component", type: ContentLoadingComponent, selector: "v-content-loading", inputs: ["width", "textSize", "hiddenText"] }, { kind: "directive", type: InfinityScrollDirective, selector: "[vInfinityScroll]", inputs: ["vInfinityScroll"], outputs: ["vInfinityScrollMore"] }, { kind: "component", type: SelectColumnComponent, selector: "v-select-column", inputs: ["selected", "data", "progress"], outputs: ["selectedChange"] }, { kind: "directive", type: i9.MatSort, selector: "[matSort]", inputs: ["matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear", "matSortDisabled"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i9.MatSortHeader, selector: "[mat-sort-header]", inputs: ["mat-sort-header", "arrowPosition", "start", "disabled", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "directive", type: i10.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: i10.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "component", type: DndColumnComponent, selector: "v-dnd-column", outputs: ["dragged"] }, { kind: "component", type: TableInfoBarComponent, selector: "v-table-info-bar", inputs: ["progress", "hasMore", "hasLoad", "isPreload", "noDownload", "noToolbar", "dataProgress", "columns", "size", "preloadSize", "count", "filteredCount", "selectedCount", "filter", "standaloneFilter", "hasInputs"], outputs: ["filterChange", "downloadCsv", "load", "preload"] }, { kind: "component", type: TableInputsComponent, selector: "v-table-inputs" }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-table', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "@let columnsData = columnsData$$ | async;\n\n<div class=\"wrapper\">\n    <v-table-info-bar\n        [(filter)]=\"filter\"\n        [columns]=\"normColumns()\"\n        [count]=\"(dataSource.data$ | async)?.length\"\n        [dataProgress]=\"!!(columnsDataProgress$ | async) && !hasMore()\"\n        [filteredCount]=\"displayedCount$ | async\"\n        [hasInputs]=\"!!tableInputsContent?.nativeElement\"\n        [hasLoad]=\"update$.observed\"\n        [hasMore]=\"hasMore()\"\n        [isPreload]=\"isPreload()\"\n        [noDownload]=\"noDownload()\"\n        [noToolbar]=\"noToolbar()\"\n        [preloadSize]=\"maxSize()\"\n        [progress]=\"progress()\"\n        [selectedCount]=\"rowSelected()?.length\"\n        [size]=\"size()\"\n        [standaloneFilter]=\"standaloneFilter()\"\n        (downloadCsv)=\"downloadCsv()\"\n        (load)=\"load()\"\n        (preload)=\"preload()\"\n    >\n        <ng-content select=\"v-table-actions\"></ng-content>\n        <v-table-inputs><ng-content select=\"v-table-inputs\"></ng-content></v-table-inputs>\n    </v-table-info-bar>\n    <mat-card #scrollViewport class=\"card\">\n        <v-no-records\n            [noRecords]=\"!(displayedCount$ | async)\"\n            [progress]=\"progress()\"\n        ></v-no-records>\n        <table\n            #matTable\n            [cdkDropListDisabled]=\"dragDisabled\"\n            [dataSource]=\"dataSource\"\n            [matSortActive]=\"(columnsDataProgress$ | async) || progress() ? '' : sort().active\"\n            [matSortDirection]=\"sort().direction\"\n            cdkDropList\n            cdkDropListData=\"dataSource\"\n            mat-table\n            matSort\n            (cdkDropListDropped)=\"drop($event)\"\n            (matSortChange)=\"sort.set($event)\"\n        >\n            @let displayedColumns = (displayedColumns$ | async) || [];\n\n            @if (displayedColumns.includes(columnDefs.drag)) {\n                <v-dnd-column\n                    [name]=\"columnDefs.drag\"\n                    (dragged)=\"dragDisabled = false\"\n                ></v-dnd-column>\n            }\n            @if (displayedColumns.includes(columnDefs.select)) {\n                <v-select-column\n                    [(selected)]=\"rowSelected\"\n                    [data]=\"displayedData$ | async\"\n                    [name]=\"columnDefs.select\"\n                    [progress]=\"progress()\"\n                ></v-select-column>\n            }\n            @for (col of displayedNormColumns$ | async; track col; let colIndex = $index) {\n                @let stickyStart = col.params.sticky === 'start';\n                @let stickyEnd = col.params.sticky === 'end';\n                @let columnClasses =\n                    {\n                        column: true,\n                        'column__sticky-start': stickyStart,\n                        'column__sticky-end': stickyEnd,\n                    };\n                <ng-container\n                    [matColumnDef]=\"col.field\"\n                    [sticky]=\"stickyStart\"\n                    [stickyEnd]=\"stickyEnd\"\n                >\n                    <th\n                        *matHeaderCellDef\n                        [disabled]=\"(col.sort | async) === false || hasMore() || progress()\"\n                        [mat-sort-header]=\"col.field\"\n                        [ngClass]=\"columnClasses\"\n                        mat-header-cell\n                    >\n                        <v-value [value]=\"col?.header | async\" emptySymbol=\"\" inline></v-value>\n                    </th>\n\n                    <ng-template let-element let-rowIndex=\"index\" matCellDef>\n                        @let cell = columnsData?.get?.(element)?.get(col);\n                        <td\n                            [ngClass]=\"columnClasses\"\n                            [ngStyle]=\"col?.params?.style\"\n                            [style.border-bottom]=\"cell?.isNextChild && !col.child ? 'none' : ''\"\n                            mat-cell\n                        >\n                            <v-value\n                                [emptySymbol]=\"!(cell?.isChild && !col?.child)\"\n                                [highlight]=\"filter$ | async\"\n                                [lazyValue]=\"cell?.lazyValue\"\n                                [lazyVisible]=\"loadedLazyItems.has(element)\"\n                                [value]=\"cell?.value | async\"\n                                inline\n                                (lazyVisibleChange)=\"loadedLazyItems.set(element, true)\"\n                            ></v-value>\n                        </td>\n                    </ng-template>\n                    <td *matFooterCellDef [ngClass]=\"columnClasses\" mat-footer-cell>\n                        <v-content-loading></v-content-loading>\n                    </td>\n                </ng-container>\n            }\n\n            <tr *matHeaderRowDef=\"displayedColumns$ | async; sticky: true\" mat-header-row></tr>\n            <tr\n                *matRowDef=\"let row; columns: displayedColumns$ | async\"\n                [cdkDragData]=\"row\"\n                cdkDrag\n                mat-row\n            ></tr>\n            <tr\n                *matFooterRowDef=\"displayedColumns$ | async\"\n                [ngClass]=\"{ row__hidden: !(hasAutoShowMore$ | async) || !tableRow }\"\n                [vInfinityScroll]=\"!progress()\"\n                mat-footer-row\n                (vInfinityScrollMore)=\"showMore()\"\n            ></tr>\n        </table>\n    </mat-card>\n</div>\n", styles: [":host{min-height:0}.wrapper{display:grid;grid-template-columns:1fr;grid-template-rows:max-content;gap:24px;height:100%}.wrapper .card{width:100%;height:100%;min-height:300px;overflow:auto;transform:translateZ(0)}.wrapper .card ::ng-deep .mdc-data-table__row:last-child .mat-mdc-cell{border-bottom-color:var(--mat-table-row-item-outline-color, rgba(0, 0, 0, .12))!important;border-bottom-width:var(--mat-table-row-item-outline-width, 1px)!important;border-bottom-style:solid!important}table ::ng-deep .cdk-drag-placeholder,::ng-deep .cdk-drag-preview ::ng-deep .cdk-drag-placeholder{background:#eee}table .column,::ng-deep .cdk-drag-preview .column{max-width:max(20px,30vw)}table .column__sticky-start,table .column__sticky-end,::ng-deep .cdk-drag-preview .column__sticky-start,::ng-deep .cdk-drag-preview .column__sticky-end{width:0}table .column__sticky-start,::ng-deep .cdk-drag-preview .column__sticky-start{border-right:1px solid}table .column__sticky-end,::ng-deep .cdk-drag-preview .column__sticky-end{border-left:1px solid}table .row__hidden,::ng-deep .cdk-drag-preview .row__hidden{display:none}::ng-deep .cdk-drag-preview{box-sizing:border-box;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f;background:#fff!important;display:flex!important;align-items:center}::ng-deep .cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}::ng-deep .cdk-drop-list-dragging ::ng-deep .mat-mdc-row:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}::ng-deep .cdk-drag-preview ::ng-deep td{border:none!important}\n"] }]
+        }], ctorParameters: () => [{ type: i0.DestroyRef }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }], propDecorators: { sortComponent: [{
+                type: ViewChild,
+                args: [MatSort]
+            }], scrollViewport: [{
+                type: ViewChild,
+                args: ['scrollViewport', { read: ElementRef }]
+            }], table: [{
+                type: ViewChild,
+                args: ['matTable', { static: false }]
+            }], tableInputsContent: [{
+                type: ContentChild,
+                args: [TableInputsComponent, { read: ElementRef }]
+            }], tableRow: [{
+                type: ViewChild,
+                args: [MatRow, { static: false }]
+            }] } });
+
+class CustomizeComponent extends DialogSuperclass {
+    constructor() {
+        super(...arguments);
+        this.columns = [
+            { field: 'priority', header: 'Number' },
+            { field: 'name' },
+            { field: 'hidden' },
+        ];
+        this.data = this.dialogData.columns.map((c, idx) => ({
+            priority: idx + 1,
+            name: c.field,
+            hidden: false,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: CustomizeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: CustomizeComponent, isStandalone: false, selector: "v-customize", usesInheritance: true, ngImport: i0, template: "<v-dialog title=\"Customize table\">\n    <v-table [columns]=\"columns\" [data]=\"data\" [rowDragDrop]=\"['priority']\" noToolbar></v-table>\n    <v-dialog-actions>\n        <button mat-button>Save</button>\n    </v-dialog-actions>\n</v-dialog>\n", dependencies: [{ kind: "component", type: i1$4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: DialogComponent, selector: "v-dialog", inputs: ["title", "disabled", "progress", "hasDivider", "noContent", "noActions", "noCloseButton", "fullSize"], outputs: ["cancel"] }, { kind: "component", type: DialogActionsComponent, selector: "v-dialog-actions" }, { kind: "component", type: TableComponent, selector: "v-table", inputs: ["data", "treeData", "columns", "progress", "hasMore", "size", "maxSize", "noDownload", "noToolbar", "filter", "standaloneFilter", "externalFilter", "rowSelectable", "rowSelected", "sort", "rowDragDrop"], outputs: ["filterChange", "rowSelectedChange", "sortChange", "rowDropped", "update", "more"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: CustomizeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-customize', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<v-dialog title=\"Customize table\">\n    <v-table [columns]=\"columns\" [data]=\"data\" [rowDragDrop]=\"['priority']\" noToolbar></v-table>\n    <v-dialog-actions>\n        <button mat-button>Save</button>\n    </v-dialog-actions>\n</v-dialog>\n" }]
+        }] });
+
+class TableActionsComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: TableActionsComponent, isStandalone: false, selector: "v-table-actions", ngImport: i0, template: `
+        <v-actions>
+            <ng-content></ng-content>
+        </v-actions>
+    `, isInline: true, dependencies: [{ kind: "component", type: ActionsComponent, selector: "v-actions" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableActionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'v-table-actions',
+                    template: `
+        <v-actions>
+            <ng-content></ng-content>
+        </v-actions>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
+                }]
+        }] });
+
+class TableProgressBarComponent {
+    constructor() {
+        this.progress = input(false, { transform: booleanAttribute });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableProgressBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: TableProgressBarComponent, isStandalone: true, selector: "v-table-progress-bar", inputs: { progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+        @if (progress()) {
+            <mat-progress-bar class="progress-bar" mode="indeterminate"></mat-progress-bar>
+        }
+    `, isInline: true, styles: [".progress-bar{position:absolute;z-index:999}\n"], dependencies: [{ kind: "component", type: MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableProgressBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-table-progress-bar', imports: [MatProgressBar], template: `
+        @if (progress()) {
+            <mat-progress-bar class="progress-bar" mode="indeterminate"></mat-progress-bar>
+        }
+    `, styles: [".progress-bar{position:absolute;z-index:999}\n"] }]
+        }] });
+
+class TableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: TableModule, declarations: [CustomizeComponent,
+            TableComponent,
+            TableInfoBarComponent,
+            TableInputsComponent,
+            TableActionsComponent], imports: [CommonModule,
+            MatTableModule,
+            MatCardModule,
+            ValueComponent,
+            TableProgressBarComponent,
+            NoRecordsComponent,
+            ContentLoadingComponent,
+            MatIcon,
+            MatTooltip,
+            MatIconButton,
+            InfinityScrollDirective,
+            ValueListComponent,
+            SelectColumnComponent,
+            ProgressModule,
+            MatSortModule,
+            MatButton,
+            CdkDrag,
+            CdkDropList,
+            DialogModule,
+            MatButtonModule,
+            InputFieldModule,
+            ActionsModule,
+            MatBadgeModule,
+            ReactiveFormsModule,
+            TagModule,
+            DndColumnComponent], exports: [TableComponent, TableInputsComponent, TableActionsComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableModule, imports: [CommonModule,
+            MatTableModule,
+            MatCardModule,
+            ValueComponent,
+            TableProgressBarComponent,
+            ContentLoadingComponent,
+            MatIcon,
+            MatIconButton,
+            ValueListComponent,
+            SelectColumnComponent,
+            ProgressModule,
+            MatSortModule,
+            MatButton,
+            DialogModule,
+            MatButtonModule,
+            InputFieldModule,
+            ActionsModule,
+            MatBadgeModule,
+            ReactiveFormsModule,
+            TagModule,
+            DndColumnComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: TableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatTableModule,
+                        MatCardModule,
+                        ValueComponent,
+                        TableProgressBarComponent,
+                        NoRecordsComponent,
+                        ContentLoadingComponent,
+                        MatIcon,
+                        MatTooltip,
+                        MatIconButton,
+                        InfinityScrollDirective,
+                        ValueListComponent,
+                        SelectColumnComponent,
+                        ProgressModule,
+                        MatSortModule,
+                        MatButton,
+                        CdkDrag,
+                        CdkDropList,
+                        DialogModule,
+                        MatButtonModule,
+                        InputFieldModule,
+                        ActionsModule,
+                        MatBadgeModule,
+                        ReactiveFormsModule,
+                        TagModule,
+                        DndColumnComponent,
+                    ],
+                    declarations: [
+                        CustomizeComponent,
+                        TableComponent,
+                        TableInfoBarComponent,
+                        TableInputsComponent,
+                        TableActionsComponent,
+                    ],
+                    exports: [TableComponent, TableInputsComponent, TableActionsComponent],
+                }]
+        }] });
+
+function correctPriorities(priorities, opts = {
+    step: 1000,
+    maxStep: 1000,
+    start: 0,
+}) {
+    if (!priorities.length) {
+        return [];
+    }
+    const res = [opts.start];
+    for (let i = 1; i < priorities.length; ++i) {
+        const last = res.at(-1) ?? opts.start;
+        if (priorities[i] === priorities[i - 1]) {
+            res.push(last);
+        }
+        else if (priorities[i] <= last || priorities[i] > last + opts.maxStep) {
+            res.push(last + opts.step);
+        }
+        else {
+            res.push(priorities[i]);
+        }
+    }
+    return res;
+}
+
+function createColumn(createCell, columnObject = {}) {
+    return (getCellParams, { isLazyCell, ...column } = {}) => {
+        const injector = inject(Injector);
+        const field = column?.field ?? createUniqueColumnDef(column?.header);
+        const cellKey = isLazyCell ? 'lazyCell' : 'cell';
+        return {
+            field,
+            ...columnObject,
+            ...column,
+            [cellKey]: (...cellArgs) => {
+                const cellValue$ = getPossiblyAsyncObservable(getCellParams(...cellArgs)).pipe(switchMap((cellParams) => getPossiblyAsyncObservable(runInInjectionContext(injector, () => createCell(cellParams, ...cellArgs)))));
+                if (column[cellKey]) {
+                    const columnCellValue$ = normalizeCell(field, column[cellKey], !!column?.child)(...cellArgs);
+                    return combineLatest([cellValue$, columnCellValue$]).pipe(map(([a, b]) => Object.assign({}, a, b, { value: b?.value || a?.value })));
+                }
+                return cellValue$;
+            },
+        };
+    };
+}
+
+const createMenuColumn = createColumn((params) => {
+    return {
+        type: 'menu',
+        params,
+    };
+}, {
+    field: 'menu',
+    header: '',
+    sticky: 'end',
+    style: {
+        padding: 0,
+        width: '0',
+    },
+});
+
+class ConfirmDialogComponent extends DialogSuperclass {
+    constructor() {
+        super(...arguments);
+        this.control = new FormControl('', { nonNullable: true });
+    }
+    confirm() {
+        this.closeWithSuccess(this.dialogData && this.dialogData?.hasReason
+            ? { reason: this.control.value }
+            : undefined);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: ConfirmDialogComponent, isStandalone: false, selector: "v-action-dialog", usesInheritance: true, ngImport: i0, template: "<v-dialog\n    [noContent]=\"!(dialogData && (dialogData.hasReason || dialogData.description))\"\n    [title]=\"dialogData?.['title'] ?? 'Confirm this action?'\"\n    noCloseButton\n>\n    @if (dialogData && dialogData.description) {\n        <div class=\"mat-body-large\">\n            {{ dialogData.description }}\n        </div>\n    }\n    @if (dialogData && dialogData.hasReason) {\n        <mat-form-field style=\"width: 100%\">\n            <mat-label>Reason</mat-label>\n            <input [formControl]=\"control\" matInput />\n        </mat-form-field>\n    }\n    <v-dialog-actions>\n        <button mat-button (click)=\"closeWithCancellation()\">Cancel</button>\n        <button mat-flat-button (click)=\"confirm()\">\n            {{ dialogData?.['confirmLabel'] || 'Confirm' }}\n        </button>\n    </v-dialog-actions>\n</v-dialog>\n", dependencies: [{ kind: "component", type: i1$4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: DialogComponent, selector: "v-dialog", inputs: ["title", "disabled", "progress", "hasDivider", "noContent", "noActions", "noCloseButton", "fullSize"], outputs: ["cancel"] }, { kind: "component", type: DialogActionsComponent, selector: "v-dialog-actions" }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-action-dialog', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<v-dialog\n    [noContent]=\"!(dialogData && (dialogData.hasReason || dialogData.description))\"\n    [title]=\"dialogData?.['title'] ?? 'Confirm this action?'\"\n    noCloseButton\n>\n    @if (dialogData && dialogData.description) {\n        <div class=\"mat-body-large\">\n            {{ dialogData.description }}\n        </div>\n    }\n    @if (dialogData && dialogData.hasReason) {\n        <mat-form-field style=\"width: 100%\">\n            <mat-label>Reason</mat-label>\n            <input [formControl]=\"control\" matInput />\n        </mat-form-field>\n    }\n    <v-dialog-actions>\n        <button mat-button (click)=\"closeWithCancellation()\">Cancel</button>\n        <button mat-flat-button (click)=\"confirm()\">\n            {{ dialogData?.['confirmLabel'] || 'Confirm' }}\n        </button>\n    </v-dialog-actions>\n</v-dialog>\n" }]
+        }] });
+
+class ConfirmDialogModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogModule, declarations: [ConfirmDialogComponent], imports: [MatDialogModule,
+            MatButtonModule,
+            DialogModule,
+            MatFormFieldModule,
+            CommonModule,
+            MatInputModule,
+            ReactiveFormsModule], exports: [ConfirmDialogComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogModule, imports: [MatDialogModule,
+            MatButtonModule,
+            DialogModule,
+            MatFormFieldModule,
+            CommonModule,
+            MatInputModule,
+            ReactiveFormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfirmDialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        MatDialogModule,
+                        MatButtonModule,
+                        DialogModule,
+                        MatFormFieldModule,
+                        CommonModule,
+                        MatInputModule,
+                        ReactiveFormsModule,
+                    ],
+                    declarations: [ConfirmDialogComponent],
+                    exports: [ConfirmDialogComponent],
+                }]
+        }] });
+
+class FiltersDialogComponent extends DialogSuperclass {
+    get isShowMainFilters() {
+        return (!this.dialogData.filters.otherFiltersDirective?.templateRef ||
+            this.dialogData.filters.merge);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersDialogComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: FiltersDialogComponent, isStandalone: false, selector: "v-filters-dialog", usesInheritance: true, ngImport: i0, template: "<v-dialog noActions title=\"Filters\">\n    <div\n        [ngClass]=\"[\n            'v-filters-dialog-cols-' +\n                (isShowMainFilters ? (dialogData.filters.repeat$ | async) : 1),\n            'filters',\n        ]\"\n    >\n        @if (isShowMainFilters) {\n            <ng-container *ngTemplateOutlet=\"dialogData.filters.mainFiltersTemplate\"></ng-container>\n        }\n        @if (dialogData.filters.otherFiltersTemplate) {\n            <div class=\"other-filters\">\n                <ng-container\n                    *ngTemplateOutlet=\"dialogData.filters.otherFiltersTemplate\"\n                ></ng-container>\n            </div>\n        }\n    </div>\n</v-dialog>\n", styles: [".filters{display:grid;grid-template-columns:1fr}.filters .other-filters{display:block!important}::ng-deep .v-filters-dialog-cols-1>*:nth-child(-n+1){display:none}::ng-deep .v-filters-dialog-cols-2>*:nth-child(-n+2){display:none}::ng-deep .v-filters-dialog-cols-3>*:nth-child(-n+3){display:none}::ng-deep .v-filters-dialog-cols-4>*:nth-child(-n+4){display:none}::ng-deep .v-filters-dialog-cols-5>*:nth-child(-n+5){display:none}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: DialogComponent, selector: "v-dialog", inputs: ["title", "disabled", "progress", "hasDivider", "noContent", "noActions", "noCloseButton", "fullSize"], outputs: ["cancel"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-filters-dialog', standalone: false, template: "<v-dialog noActions title=\"Filters\">\n    <div\n        [ngClass]=\"[\n            'v-filters-dialog-cols-' +\n                (isShowMainFilters ? (dialogData.filters.repeat$ | async) : 1),\n            'filters',\n        ]\"\n    >\n        @if (isShowMainFilters) {\n            <ng-container *ngTemplateOutlet=\"dialogData.filters.mainFiltersTemplate\"></ng-container>\n        }\n        @if (dialogData.filters.otherFiltersTemplate) {\n            <div class=\"other-filters\">\n                <ng-container\n                    *ngTemplateOutlet=\"dialogData.filters.otherFiltersTemplate\"\n                ></ng-container>\n            </div>\n        }\n    </div>\n</v-dialog>\n", styles: [".filters{display:grid;grid-template-columns:1fr}.filters .other-filters{display:block!important}::ng-deep .v-filters-dialog-cols-1>*:nth-child(-n+1){display:none}::ng-deep .v-filters-dialog-cols-2>*:nth-child(-n+2){display:none}::ng-deep .v-filters-dialog-cols-3>*:nth-child(-n+3){display:none}::ng-deep .v-filters-dialog-cols-4>*:nth-child(-n+4){display:none}::ng-deep .v-filters-dialog-cols-5>*:nth-child(-n+5){display:none}\n"] }]
+        }] });
+
+class MainFiltersDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MainFiltersDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: MainFiltersDirective, isStandalone: false, selector: "[vMainFilters]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MainFiltersDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vMainFilters]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class OtherFiltersDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: OtherFiltersDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.2", type: OtherFiltersDirective, isStandalone: false, selector: "[vOtherFilters]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: OtherFiltersDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vOtherFilters]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class FiltersComponent {
+    set content(content) {
+        this.filtersCount$.next(content?.nativeElement?.children?.length ?? 0);
+    }
+    get mainFiltersTemplate() {
+        return this.mainFiltersDirective?.templateRef ?? this.filtersTemplate;
+    }
+    get otherFiltersTemplate() {
+        return this.otherFiltersDirective?.templateRef;
+    }
+    constructor(dialog, breakpointObserver) {
+        this.dialog = dialog;
+        this.breakpointObserver = breakpointObserver;
+        this.active = 0;
+        this.merge = false;
+        // TODO: to change from outside you need to change the logic and set $rows in two SCSS
+        this.rows = signal(1);
+        this.clear = new EventEmitter();
+        this.repeat$ = this.breakpointObserver.observe(Object.values(Breakpoints)).pipe(map((b) => {
+            if (b.breakpoints[Breakpoints.XLarge]) {
+                return 5;
+            }
+            if (b.breakpoints[Breakpoints.Large]) {
+                return 4;
+            }
+            if (b.breakpoints[Breakpoints.Medium]) {
+                return 3;
+            }
+            if (b.breakpoints[Breakpoints.Small]) {
+                return 2;
+            }
+            return 1;
+        }));
+        this.displayedFiltersCount$ = combineLatest([this.repeat$, toObservable(this.rows)]).pipe(map(([repeat, rows]) => repeat * rows));
+        this.filtersCount$ = new BehaviorSubject(0);
+    }
+    open() {
+        this.dialog.open(FiltersDialogComponent, { filters: this });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersComponent, deps: [{ token: DialogService }, { token: i2$6.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "19.2.2", type: FiltersComponent, isStandalone: false, selector: "v-filters", inputs: { active: "active", merge: ["merge", "merge", booleanAttribute] }, outputs: { clear: "clear" }, queries: [{ propertyName: "filtersTemplate", first: true, predicate: TemplateRef, descendants: true, static: true }, { propertyName: "otherFiltersDirective", first: true, predicate: OtherFiltersDirective, descendants: true, static: true }, { propertyName: "mainFiltersDirective", first: true, predicate: MainFiltersDirective, descendants: true, static: true }], viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true }], ngImport: i0, template: "<mat-card>\n    <mat-card-content #content [ngClass]=\"['v-filters-cols-' + (repeat$ | async), 'filters']\">\n        <ng-container *ngTemplateOutlet=\"mainFiltersTemplate\"></ng-container>\n    </mat-card-content>\n</mat-card>\n", styles: [".filters{display:grid;grid-column-gap:8px;margin-bottom:-22px;padding:22px!important}::ng-deep .filters>*{min-width:0}::ng-deep .v-filters-cols-1{grid-template-columns:repeat(1,1fr)}::ng-deep .v-filters-cols-1>*:nth-child(n+2){display:none}::ng-deep .v-filters-cols-2{grid-template-columns:repeat(2,1fr)}::ng-deep .v-filters-cols-2>*:nth-child(n+3){display:none}::ng-deep .v-filters-cols-3{grid-template-columns:repeat(3,1fr)}::ng-deep .v-filters-cols-3>*:nth-child(n+4){display:none}::ng-deep .v-filters-cols-4{grid-template-columns:repeat(4,1fr)}::ng-deep .v-filters-cols-4>*:nth-child(n+5){display:none}::ng-deep .v-filters-cols-5{grid-template-columns:repeat(5,1fr)}::ng-deep .v-filters-cols-5>*:nth-child(n+6){display:none}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i4.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i4.MatCardContent, selector: "mat-card-content" }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-filters', standalone: false, template: "<mat-card>\n    <mat-card-content #content [ngClass]=\"['v-filters-cols-' + (repeat$ | async), 'filters']\">\n        <ng-container *ngTemplateOutlet=\"mainFiltersTemplate\"></ng-container>\n    </mat-card-content>\n</mat-card>\n", styles: [".filters{display:grid;grid-column-gap:8px;margin-bottom:-22px;padding:22px!important}::ng-deep .filters>*{min-width:0}::ng-deep .v-filters-cols-1{grid-template-columns:repeat(1,1fr)}::ng-deep .v-filters-cols-1>*:nth-child(n+2){display:none}::ng-deep .v-filters-cols-2{grid-template-columns:repeat(2,1fr)}::ng-deep .v-filters-cols-2>*:nth-child(n+3){display:none}::ng-deep .v-filters-cols-3{grid-template-columns:repeat(3,1fr)}::ng-deep .v-filters-cols-3>*:nth-child(n+4){display:none}::ng-deep .v-filters-cols-4{grid-template-columns:repeat(4,1fr)}::ng-deep .v-filters-cols-4>*:nth-child(n+5){display:none}::ng-deep .v-filters-cols-5{grid-template-columns:repeat(5,1fr)}::ng-deep .v-filters-cols-5>*:nth-child(n+6){display:none}\n"] }]
+        }], ctorParameters: () => [{ type: DialogService }, { type: i2$6.BreakpointObserver }], propDecorators: { active: [{
+                type: Input
+            }], merge: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], clear: [{
+                type: Output
+            }], filtersTemplate: [{
+                type: ContentChild,
+                args: [TemplateRef, { static: true }]
+            }], otherFiltersDirective: [{
+                type: ContentChild,
+                args: [OtherFiltersDirective, { static: true }]
+            }], mainFiltersDirective: [{
+                type: ContentChild,
+                args: [MainFiltersDirective, { static: true }]
+            }], content: [{
+                type: ViewChild,
+                args: ['content']
+            }] } });
+
+class MoreFiltersButtonComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MoreFiltersButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: MoreFiltersButtonComponent, isStandalone: false, selector: "v-more-filters-button", inputs: { filters: "filters" }, ngImport: i0, template: "<v-actions>\n    @if (filters.active && filters.clear.observed) {\n        <button mat-icon-button (click)=\"filters.clear.emit()\">\n            <mat-icon [matBadge]=\"filters.active || undefined\" matBadgeColor=\"accent\"\n                >restart_alt</mat-icon\n            >\n        </button>\n    }\n    @if (\n        filters.otherFiltersDirective ||\n        ((filters.filtersCount$ | async) ?? 0) - ((filters.displayedFiltersCount$ | async) ?? 0) > 0\n    ) {\n        <button mat-icon-button (click)=\"filters.open()\">\n            <mat-icon>filter_alt</mat-icon>\n        </button>\n    }\n</v-actions>\n", styles: [""], dependencies: [{ kind: "component", type: i1$4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: ActionsComponent, selector: "v-actions" }, { kind: "directive", type: i6.MatBadge, selector: "[matBadge]", inputs: ["matBadgeColor", "matBadgeOverlap", "matBadgeDisabled", "matBadgePosition", "matBadge", "matBadgeDescription", "matBadgeSize", "matBadgeHidden"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: MoreFiltersButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-more-filters-button', standalone: false, template: "<v-actions>\n    @if (filters.active && filters.clear.observed) {\n        <button mat-icon-button (click)=\"filters.clear.emit()\">\n            <mat-icon [matBadge]=\"filters.active || undefined\" matBadgeColor=\"accent\"\n                >restart_alt</mat-icon\n            >\n        </button>\n    }\n    @if (\n        filters.otherFiltersDirective ||\n        ((filters.filtersCount$ | async) ?? 0) - ((filters.displayedFiltersCount$ | async) ?? 0) > 0\n    ) {\n        <button mat-icon-button (click)=\"filters.open()\">\n            <mat-icon>filter_alt</mat-icon>\n        </button>\n    }\n</v-actions>\n" }]
+        }], propDecorators: { filters: [{
+                type: Input
+            }] } });
+
+class FiltersModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: FiltersModule, declarations: [FiltersComponent,
+            MoreFiltersButtonComponent,
+            FiltersDialogComponent,
+            OtherFiltersDirective,
+            MainFiltersDirective], imports: [CommonModule,
+            MatCardModule,
+            MatButtonModule,
+            MatIconModule,
+            DialogModule,
+            LayoutModule,
+            ActionsModule,
+            MatBadgeModule], exports: [FiltersComponent,
+            MoreFiltersButtonComponent,
+            OtherFiltersDirective,
+            MainFiltersDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersModule, imports: [CommonModule,
+            MatCardModule,
+            MatButtonModule,
+            MatIconModule,
+            DialogModule,
+            LayoutModule,
+            ActionsModule,
+            MatBadgeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FiltersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        FiltersComponent,
+                        MoreFiltersButtonComponent,
+                        FiltersDialogComponent,
+                        OtherFiltersDirective,
+                        MainFiltersDirective,
+                    ],
+                    exports: [
+                        FiltersComponent,
+                        MoreFiltersButtonComponent,
+                        OtherFiltersDirective,
+                        MainFiltersDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                        MatCardModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        DialogModule,
+                        LayoutModule,
+                        ActionsModule,
+                        MatBadgeModule,
+                    ],
+                }]
+        }] });
+
+class DateRangeFieldComponent extends FormGroupSuperclass {
+    constructor(fb) {
+        super();
+        this.fb = fb;
+        this.required = false;
+        this.control = this.fb.group({
+            start: undefined,
+            end: undefined,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldComponent, deps: [{ token: i1$3.NonNullableFormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: DateRangeFieldComponent, isStandalone: false, selector: "v-date-range-field", inputs: { required: ["required", "required", booleanAttribute] }, providers: [
+            ...createControlProviders(() => DateRangeFieldComponent),
+            { provide: MAT_DATE_LOCALE, useValue: enGB },
+            { provide: DateAdapter, useClass: DateFnsAdapter, deps: [MAT_DATE_LOCALE] },
+            { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS },
+        ], usesInheritance: true, ngImport: i0, template: "<mat-form-field>\n    <mat-label>Date range</mat-label>\n    <mat-date-range-input\n        [formGroup]=\"control\"\n        [rangePicker]=\"picker\"\n        [required]=\"required || false\"\n    >\n        <input formControlName=\"start\" matStartDate placeholder=\"Start date\" />\n        <input formControlName=\"end\" matEndDate placeholder=\"End date\" />\n    </mat-date-range-input>\n    <mat-datepicker-toggle [for]=\"picker\" matIconSuffix></mat-datepicker-toggle>\n    <mat-date-range-picker #picker>\n        <mat-date-range-picker-actions>\n            <v-actions class=\"actions\">\n                @if (!required) {\n                    <button\n                        [disabled]=\"!control.value?.start && !control.value?.end\"\n                        mat-button\n                        (click)=\"control.reset(); picker.close()\"\n                    >\n                        Reset\n                    </button>\n                }\n                <button mat-flat-button matDateRangePickerApply>Apply</button>\n            </v-actions>\n        </mat-date-range-picker-actions>\n    </mat-date-range-picker>\n</mat-form-field>\n", styles: [":host{overflow:hidden}mat-form-field{width:100%}::ng-deep .mat-mdc-form-field-infix{width:auto!important}input{text-overflow:ellipsis}.actions{width:100%}\n"], dependencies: [{ kind: "component", type: i2$7.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "component", type: i2$7.MatDateRangeInput, selector: "mat-date-range-input", inputs: ["rangePicker", "required", "dateFilter", "min", "max", "disabled", "separator", "comparisonStart", "comparisonEnd"], exportAs: ["matDateRangeInput"] }, { kind: "directive", type: i2$7.MatStartDate, selector: "input[matStartDate]", outputs: ["dateChange", "dateInput"] }, { kind: "directive", type: i2$7.MatEndDate, selector: "input[matEndDate]", outputs: ["dateChange", "dateInput"] }, { kind: "component", type: i2$7.MatDateRangePicker, selector: "mat-date-range-picker", exportAs: ["matDateRangePicker"] }, { kind: "component", type: i2$7.MatDatepickerActions, selector: "mat-datepicker-actions, mat-date-range-picker-actions" }, { kind: "directive", type: i2$7.MatDatepickerApply, selector: "[matDatepickerApply], [matDateRangePickerApply]" }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1$3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1$3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i1$4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: ActionsComponent, selector: "v-actions" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-date-range-field', providers: [
+                        ...createControlProviders(() => DateRangeFieldComponent),
+                        { provide: MAT_DATE_LOCALE, useValue: enGB },
+                        { provide: DateAdapter, useClass: DateFnsAdapter, deps: [MAT_DATE_LOCALE] },
+                        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS },
+                    ], standalone: false, template: "<mat-form-field>\n    <mat-label>Date range</mat-label>\n    <mat-date-range-input\n        [formGroup]=\"control\"\n        [rangePicker]=\"picker\"\n        [required]=\"required || false\"\n    >\n        <input formControlName=\"start\" matStartDate placeholder=\"Start date\" />\n        <input formControlName=\"end\" matEndDate placeholder=\"End date\" />\n    </mat-date-range-input>\n    <mat-datepicker-toggle [for]=\"picker\" matIconSuffix></mat-datepicker-toggle>\n    <mat-date-range-picker #picker>\n        <mat-date-range-picker-actions>\n            <v-actions class=\"actions\">\n                @if (!required) {\n                    <button\n                        [disabled]=\"!control.value?.start && !control.value?.end\"\n                        mat-button\n                        (click)=\"control.reset(); picker.close()\"\n                    >\n                        Reset\n                    </button>\n                }\n                <button mat-flat-button matDateRangePickerApply>Apply</button>\n            </v-actions>\n        </mat-date-range-picker-actions>\n    </mat-date-range-picker>\n</mat-form-field>\n", styles: [":host{overflow:hidden}mat-form-field{width:100%}::ng-deep .mat-mdc-form-field-infix{width:auto!important}input{text-overflow:ellipsis}.actions{width:100%}\n"] }]
+        }], ctorParameters: () => [{ type: i1$3.NonNullableFormBuilder }], propDecorators: { required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+
+class DateRangeFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldModule, declarations: [DateRangeFieldComponent], imports: [CommonModule,
+            MatDatepickerModule,
+            MatInputModule,
+            ReactiveFormsModule,
+            MatButtonModule,
+            ActionsModule], exports: [DateRangeFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldModule, imports: [CommonModule,
+            MatDatepickerModule,
+            MatInputModule,
+            ReactiveFormsModule,
+            MatButtonModule,
+            ActionsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DateRangeFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DateRangeFieldComponent],
+                    imports: [
+                        CommonModule,
+                        MatDatepickerModule,
+                        MatInputModule,
+                        ReactiveFormsModule,
+                        MatButtonModule,
+                        ActionsModule,
+                    ],
+                    exports: [DateRangeFieldComponent],
+                }]
+        }] });
+
+function isEqualDateRange(a, b) {
+    if (!a || !b) {
+        return a === b;
+    }
+    return isEqual$2(a.start, b.start) && isEqual$2(a.end, b.end);
+}
+
+function createDateRangeToToday(minDays = 1) {
+    return {
+        /**
+         * If we take the beginning of the previous day to the end of the current one,
+         * then it is guaranteed that there will be an interval of one day,
+         * as a maximum of two days
+         */
+        start: subDays(startOfDay(new Date()), minDays),
+        end: endOfDay(new Date()),
+    };
+}
+
+class NumberRangeFieldComponent extends FormGroupSuperclass {
+    constructor(fb) {
+        super();
+        this.fb = fb;
+        this.control = this.fb.group({
+            start: undefined,
+            end: undefined,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldComponent, deps: [{ token: i1$3.NonNullableFormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: NumberRangeFieldComponent, isStandalone: false, selector: "v-number-range-field", inputs: { label: "label" }, providers: createControlProviders(() => NumberRangeFieldComponent), usesInheritance: true, ngImport: i0, template: "<div [formGroup]=\"control\" class=\"wrapper\">\n    <mat-form-field>\n        <mat-label>{{ label }} from</mat-label>\n        <input formControlName=\"start\" matInput type=\"number\" />\n    </mat-form-field>\n    <mat-form-field>\n        <mat-label>{{ label }} to</mat-label>\n        <input formControlName=\"end\" matInput type=\"number\" />\n    </mat-form-field>\n</div>\n", styles: [".wrapper{display:grid;grid-template-columns:1fr 1fr;grid-gap:8px}\n"], dependencies: [{ kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1$3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1$3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-number-range-field', providers: createControlProviders(() => NumberRangeFieldComponent), standalone: false, template: "<div [formGroup]=\"control\" class=\"wrapper\">\n    <mat-form-field>\n        <mat-label>{{ label }} from</mat-label>\n        <input formControlName=\"start\" matInput type=\"number\" />\n    </mat-form-field>\n    <mat-form-field>\n        <mat-label>{{ label }} to</mat-label>\n        <input formControlName=\"end\" matInput type=\"number\" />\n    </mat-form-field>\n</div>\n", styles: [".wrapper{display:grid;grid-template-columns:1fr 1fr;grid-gap:8px}\n"] }]
+        }], ctorParameters: () => [{ type: i1$3.NonNullableFormBuilder }], propDecorators: { label: [{
+                type: Input
+            }] } });
+
+class NumberRangeFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldModule, declarations: [NumberRangeFieldComponent], imports: [ReactiveFormsModule, MatInputModule], exports: [NumberRangeFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldModule, imports: [ReactiveFormsModule, MatInputModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NumberRangeFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NumberRangeFieldComponent],
+                    imports: [ReactiveFormsModule, MatInputModule],
+                    exports: [NumberRangeFieldComponent],
+                }]
+        }] });
+
+class ListFieldComponent extends FormControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.items$ = getValueChanges(this.control).pipe(map((v) => this.getValue(v)), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    innerToOuterValue(inner) {
+        return this.getValue(inner);
+    }
+    outerToInnerValue(outer) {
+        return (outer || []).join(', ');
+    }
+    getValue(inner = this.control.value) {
+        return splitBySeparators(inner || '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ListFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: ListFieldComponent, isStandalone: false, selector: "v-list-field", inputs: { label: "label", focusedHint: "focusedHint" }, providers: createControlProviders(() => ListFieldComponent), usesInheritance: true, ngImport: i0, template: "<mat-form-field style=\"width: 100%\">\n    <mat-label>{{ label }}</mat-label>\n    <input #input=\"matInput\" [formControl]=\"control\" autocomplete=\"false\" matInput type=\"string\" />\n    <mat-hint class=\"mat-secondary-text\">{{\n        (items$ | async)?.length\n            ? (items$ | async)?.length === 1\n                ? '1 item'\n                : (items$ | async)?.length + ' items'\n            : input.focused\n              ? focusedHint || 'item_1, item_2'\n              : ''\n    }}</mat-hint>\n</mat-form-field>\n", dependencies: [{ kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ListFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-list-field', providers: createControlProviders(() => ListFieldComponent), standalone: false, template: "<mat-form-field style=\"width: 100%\">\n    <mat-label>{{ label }}</mat-label>\n    <input #input=\"matInput\" [formControl]=\"control\" autocomplete=\"false\" matInput type=\"string\" />\n    <mat-hint class=\"mat-secondary-text\">{{\n        (items$ | async)?.length\n            ? (items$ | async)?.length === 1\n                ? '1 item'\n                : (items$ | async)?.length + ' items'\n            : input.focused\n              ? focusedHint || 'item_1, item_2'\n              : ''\n    }}</mat-hint>\n</mat-form-field>\n" }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], focusedHint: [{
+                type: Input
+            }] } });
+
+class ListFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ListFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ListFieldModule, declarations: [ListFieldComponent], imports: [CommonModule, MatInputModule, ReactiveFormsModule], exports: [ListFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ListFieldModule, imports: [CommonModule, MatInputModule, ReactiveFormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ListFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ListFieldComponent],
+                    exports: [ListFieldComponent],
+                    imports: [CommonModule, MatInputModule, ReactiveFormsModule],
+                }]
+        }] });
+
+class ErrorPageComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: ErrorPageComponent, isStandalone: false, selector: "ng-component", ngImport: i0, template: "<div class=\"error\">\n    <div class=\"mat-display-small title\">\n        <mat-icon>error</mat-icon>\n        <div>Page not found</div>\n    </div>\n    <h2 class=\"mat-headline-small mat-secondary-text\">\n        This page doesn't exist<br />or no permission to access this page\n    </h2>\n</div>\n", styles: [".error{margin:0 auto;padding:96px 24px;text-align:center}.error .title{display:flex;flex-wrap:wrap;justify-content:center;align-items:center;gap:16px}.error .title mat-icon{font-size:40px;width:auto;height:auto}\n"], dependencies: [{ kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, template: "<div class=\"error\">\n    <div class=\"mat-display-small title\">\n        <mat-icon>error</mat-icon>\n        <div>Page not found</div>\n    </div>\n    <h2 class=\"mat-headline-small mat-secondary-text\">\n        This page doesn't exist<br />or no permission to access this page\n    </h2>\n</div>\n", styles: [".error{margin:0 auto;padding:96px 24px;text-align:center}.error .title{display:flex;flex-wrap:wrap;justify-content:center;align-items:center;gap:16px}.error .title mat-icon{font-size:40px;width:auto;height:auto}\n"] }]
+        }] });
+
+const ROUTES = [{ path: '', component: ErrorPageComponent }];
+class ErrorPageRoutingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageRoutingModule, imports: [i1$6.RouterModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageRoutingModule, imports: [RouterModule.forChild(ROUTES), RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [RouterModule.forChild(ROUTES)],
+                    exports: [RouterModule],
+                }]
+        }] });
+
+class ErrorPageModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageModule, declarations: [ErrorPageComponent], imports: [ErrorPageRoutingModule, MatIconModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageModule, imports: [ErrorPageRoutingModule, MatIconModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ErrorPageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ErrorPageRoutingModule, MatIconModule],
+                    declarations: [ErrorPageComponent],
+                }]
+        }] });
+
+function isSearchOption(option, termLowerCase) {
+    return (!!String(option.value)?.toLowerCase().includes?.(termLowerCase) ||
+        !!option.label?.toLowerCase()?.includes(termLowerCase) ||
+        !!option.description?.toLowerCase().includes?.(termLowerCase));
+}
+function searchOptions(options, term) {
+    const termLowerCase = term.toLowerCase();
+    return options?.filter?.((option) => isSearchOption(option, termLowerCase));
+}
+
+function findOptionByValue(options, value) {
+    return options?.find?.((o) => o.value === value);
+}
+
+function getHintText(options, selected, hint, opts = {}) {
+    if (!isNil(hint)) {
+        return hint;
+    }
+    if (opts.multiple && options?.length > 1) {
+        return (selected?.length || 0) + '/' + options.length;
+    }
+    if (!selected?.length) {
+        return '';
+    }
+    const option = findOptionByValue(options, selected[0]);
+    return opts.showLabel ? option?.label : option?.description;
+}
+
+class SelectFieldComponent extends FormControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.options = [];
+        this.searchChange = new EventEmitter();
+        this.appearance = 'fill';
+        this.progress = false;
+        this.externalSearch = false;
+        this.multiple = false;
+        this.required = false;
+        this.searchStr = '';
+        this.search = (term, item) => {
+            return this.externalSearch || isSearchOption(item, term.toLowerCase());
+        };
+    }
+    get hintText() {
+        return getHintText(this.options, this.multiple ? this.control.value : [this.control.value], this.hint, {
+            multiple: this.multiple,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "19.2.2", type: SelectFieldComponent, isStandalone: false, selector: "v-select-field", inputs: { options: "options", appearance: "appearance", label: "label", hint: "hint", error: "error", progress: "progress", externalSearch: ["externalSearch", "externalSearch", booleanAttribute], multiple: ["multiple", "multiple", booleanAttribute], required: ["required", "required", booleanAttribute], size: "size" }, outputs: { searchChange: "searchChange" }, providers: createControlProviders(() => SelectFieldComponent), usesInheritance: true, ngImport: i0, template: "<mat-form-field [appearance]=\"appearance\" [ngClass]=\"{ 'v-input-field__small': size === 'small' }\">\n    <mat-label>{{ label }}</mat-label>\n\n    <mtx-select\n        [closeOnSelect]=\"!multiple\"\n        [formControl]=\"control\"\n        [items]=\"options\"\n        [loading]=\"progress\"\n        [markFirst]=\"true\"\n        [multiple]=\"multiple\"\n        [notFoundText]=\"externalSearch && !searchStr ? 'Enter your search term' : 'No items found'\"\n        [required]=\"required\"\n        [searchable]=\"true\"\n        [searchFn]=\"search\"\n        [selectableGroup]=\"true\"\n        [selectableGroupAsModel]=\"false\"\n        bindLabel=\"label\"\n        bindValue=\"value\"\n        groupBy=\"type\"\n        (clear)=\"searchChange.emit(''); searchStr = ''\"\n        (search)=\"searchChange.emit($event.term); searchStr = $event.term\"\n    >\n        <ng-template let-index=\"index\" let-item=\"item\" let-item$=\"item$\" ng-optgroup-tmp>\n            <mat-checkbox\n                *ngIf=\"multiple; else text\"\n                [ngModel]=\"item$.selected\"\n                class=\"checkbox-option\"\n                id=\"item-{{ index }}\"\n            >\n                {{ item.type | uppercase }}\n            </mat-checkbox>\n            <ng-template #text>\n                {{ item.type | uppercase }}\n            </ng-template>\n        </ng-template>\n        <ng-template let-index=\"index\" let-item=\"item\" let-item$=\"item$\" ng-option-tmp>\n            <mat-checkbox\n                *ngIf=\"multiple; else text\"\n                [ngModel]=\"item$.selected\"\n                class=\"checkbox-option\"\n                id=\"item-{{ index }}\"\n            >\n                <ng-container *ngTemplateOutlet=\"text\"></ng-container>\n            </mat-checkbox>\n            <ng-template #text>\n                <div class=\"label\">{{ item.label }}</div>\n                <div\n                    *ngIf=\"item.description\"\n                    class=\"description mat-label-medium mat-secondary-text\"\n                >\n                    {{ item.description }}\n                </div>\n            </ng-template>\n        </ng-template>\n    </mtx-select>\n\n    <mat-hint>{{ hintText }}</mat-hint>\n    <mat-error>{{ error }}</mat-error>\n</mat-form-field>\n", styles: ["::ng-deep .mat-mdc-form-field{width:100%}::ng-deep .mat-mdc-form-field>*{max-height:56px}::ng-deep .mat-mdc-form-field .ng-value-container{flex-wrap:nowrap!important;overflow-x:hidden}::ng-deep .ng-dropdown-panel.ng-select-bottom{margin-top:-4px}.checkbox-option{margin:-12px 0 -12px -8px}.label,.description{overflow:hidden;text-overflow:ellipsis}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i3.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "component", type: i3$2.MtxSelect, selector: "mtx-select", inputs: ["addTag", "addTagText", "appearance", "appendTo", "bindLabel", "bindValue", "closeOnSelect", "clearAllText", "clearable", "clearOnBackspace", "compareWith", "dropdownPosition", "groupBy", "groupValue", "bufferAmount", "selectableGroup", "selectableGroupAsModel", "hideSelected", "loading", "loadingText", "labelForId", "markFirst", "maxSelectedItems", "multiple", "notFoundText", "searchable", "readonly", "searchFn", "searchWhileComposing", "selectOnTab", "trackByFn", "inputAttrs", "tabIndex", "openOnEnter", "minTermLength", "editableSearchTerm", "keyDownFn", "virtualScroll", "typeToSearchText", "typeahead", "isOpen", "fixedPlaceholder", "deselectOnClick", "clearSearchOnAdd", "items", "value", "id", "placeholder", "disabled", "required", "errorStateMatcher", "aria-label", "aria-labelledby"], outputs: ["blur", "focus", "change", "open", "close", "search", "clear", "add", "remove", "scroll", "scrollToEnd"], exportAs: ["mtxSelect"] }, { kind: "directive", type: i3$2.MtxSelectOptgroupTemplate, selector: "[ng-optgroup-tmp]" }, { kind: "directive", type: i3$2.MtxSelectOptionTemplate, selector: "[ng-option-tmp]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1$3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i3$1.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "aria-expanded", "aria-controls", "aria-owns", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "disabledInteractive", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "pipe", type: i1$1.UpperCasePipe, name: "uppercase" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-select-field', providers: createControlProviders(() => SelectFieldComponent), standalone: false, template: "<mat-form-field [appearance]=\"appearance\" [ngClass]=\"{ 'v-input-field__small': size === 'small' }\">\n    <mat-label>{{ label }}</mat-label>\n\n    <mtx-select\n        [closeOnSelect]=\"!multiple\"\n        [formControl]=\"control\"\n        [items]=\"options\"\n        [loading]=\"progress\"\n        [markFirst]=\"true\"\n        [multiple]=\"multiple\"\n        [notFoundText]=\"externalSearch && !searchStr ? 'Enter your search term' : 'No items found'\"\n        [required]=\"required\"\n        [searchable]=\"true\"\n        [searchFn]=\"search\"\n        [selectableGroup]=\"true\"\n        [selectableGroupAsModel]=\"false\"\n        bindLabel=\"label\"\n        bindValue=\"value\"\n        groupBy=\"type\"\n        (clear)=\"searchChange.emit(''); searchStr = ''\"\n        (search)=\"searchChange.emit($event.term); searchStr = $event.term\"\n    >\n        <ng-template let-index=\"index\" let-item=\"item\" let-item$=\"item$\" ng-optgroup-tmp>\n            <mat-checkbox\n                *ngIf=\"multiple; else text\"\n                [ngModel]=\"item$.selected\"\n                class=\"checkbox-option\"\n                id=\"item-{{ index }}\"\n            >\n                {{ item.type | uppercase }}\n            </mat-checkbox>\n            <ng-template #text>\n                {{ item.type | uppercase }}\n            </ng-template>\n        </ng-template>\n        <ng-template let-index=\"index\" let-item=\"item\" let-item$=\"item$\" ng-option-tmp>\n            <mat-checkbox\n                *ngIf=\"multiple; else text\"\n                [ngModel]=\"item$.selected\"\n                class=\"checkbox-option\"\n                id=\"item-{{ index }}\"\n            >\n                <ng-container *ngTemplateOutlet=\"text\"></ng-container>\n            </mat-checkbox>\n            <ng-template #text>\n                <div class=\"label\">{{ item.label }}</div>\n                <div\n                    *ngIf=\"item.description\"\n                    class=\"description mat-label-medium mat-secondary-text\"\n                >\n                    {{ item.description }}\n                </div>\n            </ng-template>\n        </ng-template>\n    </mtx-select>\n\n    <mat-hint>{{ hintText }}</mat-hint>\n    <mat-error>{{ error }}</mat-error>\n</mat-form-field>\n", styles: ["::ng-deep .mat-mdc-form-field{width:100%}::ng-deep .mat-mdc-form-field>*{max-height:56px}::ng-deep .mat-mdc-form-field .ng-value-container{flex-wrap:nowrap!important;overflow-x:hidden}::ng-deep .ng-dropdown-panel.ng-select-bottom{margin-top:-4px}.checkbox-option{margin:-12px 0 -12px -8px}.label,.description{overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], propDecorators: { options: [{
+                type: Input
+            }], searchChange: [{
+                type: Output
+            }], appearance: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], progress: [{
+                type: Input
+            }], externalSearch: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], size: [{
+                type: Input
+            }] } });
+
+class SelectFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldModule, declarations: [SelectFieldComponent], imports: [CommonModule,
+            MatInputModule,
+            MtxSelectModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatCheckboxModule], exports: [SelectFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldModule, imports: [CommonModule,
+            MatInputModule,
+            MtxSelectModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatCheckboxModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SelectFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SelectFieldComponent],
+                    exports: [SelectFieldComponent],
+                    imports: [
+                        CommonModule,
+                        MatInputModule,
+                        MtxSelectModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatCheckboxModule,
+                    ],
+                }]
+        }] });
+
+class AutocompleteFieldComponent extends FormControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.options = [];
+        this.type = 'text';
+        this.mono = false;
+        this.required = false;
+        this.options$ = new BehaviorSubject([]);
+        this.selected$ = merge(this.control.valueChanges, this.options$).pipe(map(() => (this.options || []).find((o) => o.value === this.control.value)), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.filteredOptions$ = merge(this.control.valueChanges, this.options$).pipe(map(() => String(this.control.value ?? '').toLowerCase()), map((filter) => searchOptions(this.options, filter)), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    get hintText() {
+        return getHintText(this.options, [this.control.value], this.hint, { showLabel: true });
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        if (changes.options) {
+            this.options$.next(this.options || []);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: AutocompleteFieldComponent, isStandalone: false, selector: "v-autocomplete-field", inputs: { options: "options", label: "label", hint: "hint", error: "error", type: "type", mono: ["mono", "mono", booleanAttribute], required: ["required", "required", booleanAttribute] }, providers: createControlProviders(() => AutocompleteFieldComponent), usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<mat-form-field style=\"width: 100%\">\n    <mat-label>{{ label }}</mat-label>\n\n    <input\n        #trigger=\"matAutocompleteTrigger\"\n        [formControl]=\"control\"\n        [matAutocomplete]=\"auto\"\n        [ngClass]=\"{ 'mat-mono': mono }\"\n        [required]=\"required\"\n        [type]=\"options?.length ? 'text' : type\"\n        matInput\n    />\n\n    <mat-autocomplete #auto=\"matAutocomplete\" autoActiveFirstOption>\n        @for (option of filteredOptions$ | async; track option) {\n            <mat-option [value]=\"option.value\">\n                <div [ngClass]=\"{ 'mat-mono': mono }\" class=\"label\">{{ option.label }}</div>\n                @if (option.description) {\n                    <div\n                        [ngClass]=\"{ 'mat-mono': mono }\"\n                        class=\"description mat-label-medium mat-secondary-text\"\n                    >\n                        {{ option.description }}\n                    </div>\n                }\n            </mat-option>\n        }\n    </mat-autocomplete>\n\n    <div matSuffix style=\"display: flex; gap: 4px\">\n        @if (control.value) {\n            <button mat-icon-button (click)=\"control.reset(); $event.stopPropagation()\">\n                <mat-icon>clear</mat-icon>\n            </button>\n        }\n        @if (options?.length) {\n            <button\n                mat-icon-button\n                (click)=\"\n                    auto.isOpen ? trigger.closePanel() : trigger.openPanel();\n                    $event.stopPropagation()\n                \"\n            >\n                <mat-icon>{{ auto.isOpen ? 'expand_less' : 'expand_more' }}</mat-icon>\n            </button>\n        }\n    </div>\n    <mat-hint>{{ hintText }}</mat-hint>\n    <mat-error>{{\n        error ??\n            ((selected$ | async) ? (selected$ | async)?.label + (hint ? ' | ' + hint : '') : hint)\n    }}</mat-error>\n</mat-form-field>\n", styles: [".label,.description{overflow:hidden;text-overflow:ellipsis}\n"], dependencies: [{ kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i3.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i3.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "directive", type: i1$3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1$3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["aria-label", "aria-labelledby", "displayWith", "autoActiveFirstOption", "autoSelectActiveOption", "requireSelection", "panelWidth", "disableRipple", "class", "hideSingleSelectionIndicator"], outputs: ["optionSelected", "opened", "closed", "optionActivated"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i6$1.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "directive", type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", inputs: ["matAutocomplete", "matAutocompletePosition", "matAutocompleteConnectedTo", "autocomplete", "matAutocompleteDisabled"], exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i1$4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-autocomplete-field', providers: createControlProviders(() => AutocompleteFieldComponent), standalone: false, template: "<mat-form-field style=\"width: 100%\">\n    <mat-label>{{ label }}</mat-label>\n\n    <input\n        #trigger=\"matAutocompleteTrigger\"\n        [formControl]=\"control\"\n        [matAutocomplete]=\"auto\"\n        [ngClass]=\"{ 'mat-mono': mono }\"\n        [required]=\"required\"\n        [type]=\"options?.length ? 'text' : type\"\n        matInput\n    />\n\n    <mat-autocomplete #auto=\"matAutocomplete\" autoActiveFirstOption>\n        @for (option of filteredOptions$ | async; track option) {\n            <mat-option [value]=\"option.value\">\n                <div [ngClass]=\"{ 'mat-mono': mono }\" class=\"label\">{{ option.label }}</div>\n                @if (option.description) {\n                    <div\n                        [ngClass]=\"{ 'mat-mono': mono }\"\n                        class=\"description mat-label-medium mat-secondary-text\"\n                    >\n                        {{ option.description }}\n                    </div>\n                }\n            </mat-option>\n        }\n    </mat-autocomplete>\n\n    <div matSuffix style=\"display: flex; gap: 4px\">\n        @if (control.value) {\n            <button mat-icon-button (click)=\"control.reset(); $event.stopPropagation()\">\n                <mat-icon>clear</mat-icon>\n            </button>\n        }\n        @if (options?.length) {\n            <button\n                mat-icon-button\n                (click)=\"\n                    auto.isOpen ? trigger.closePanel() : trigger.openPanel();\n                    $event.stopPropagation()\n                \"\n            >\n                <mat-icon>{{ auto.isOpen ? 'expand_less' : 'expand_more' }}</mat-icon>\n            </button>\n        }\n    </div>\n    <mat-hint>{{ hintText }}</mat-hint>\n    <mat-error>{{\n        error ??\n            ((selected$ | async) ? (selected$ | async)?.label + (hint ? ' | ' + hint : '') : hint)\n    }}</mat-error>\n</mat-form-field>\n", styles: [".label,.description{overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], propDecorators: { options: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], mono: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+
+class AutocompleteFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldModule, declarations: [AutocompleteFieldComponent], imports: [CommonModule,
+            MatInputModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatButtonModule,
+            MatIconModule], exports: [AutocompleteFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldModule, imports: [CommonModule,
+            MatInputModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatButtonModule,
+            MatIconModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AutocompleteFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AutocompleteFieldComponent],
+                    exports: [AutocompleteFieldComponent],
+                    imports: [
+                        CommonModule,
+                        MatInputModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatAutocompleteModule,
+                        MatButtonModule,
+                        MatIconModule,
+                    ],
+                }]
+        }] });
+
+class ConfigServiceSuperclass {
+    constructor(http) {
+        this.http = http;
+    }
+    async init({ configUrl }) {
+        this.config = await lastValueFrom(this.http.get(configUrl));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfigServiceSuperclass, deps: [{ token: i1$7.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfigServiceSuperclass }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: ConfigServiceSuperclass, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$7.HttpClient }] });
+
+const DEFAULT_ERROR_NAME = 'Unknown error';
+class LogError {
+    get name() {
+        return String(this.source?.['name'] || DEFAULT_ERROR_NAME);
+    }
+    get message() {
+        return String(this.source?.['message'] || this.name);
+    }
+    get cause() {
+        return this.source?.['cause'];
+    }
+    get details() {
+        return Object.fromEntries(Object.entries(this.source).filter(([k, v]) => k !== 'name' && k !== 'message' && v));
+    }
+    constructor(error) {
+        this.source = (isObject$1(error)
+            ? error
+            : new Error(error ? String(error) : DEFAULT_ERROR_NAME));
+    }
+    getLogMessage(message) {
+        return [
+            message && `Caught error: ${message}`,
+            this.name && `Name: ${this.name}`,
+            this.message && `Message: ${this.message}`,
+            Object.keys(this.details).length && JSON.stringify(this.details, null, 2),
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+}
+
+const DEFAULT_DURATION_MS = 3_000;
+const DEFAULT_ERROR_DURATION_MS = 10_000;
+const DEFAULT_TIMEOUT_MS = 10_000;
+class NotifyLogService {
+    constructor(snackBar) {
+        this.snackBar = snackBar;
+        this.success = (message = 'Completed successfully') => {
+            this.notify(message);
+        };
+        this.error = (errors, message) => {
+            const logErrors = (Array.isArray(errors) ? errors : [errors]).map((e) => new LogError(e));
+            message = message || (logErrors.length === 1 ? logErrors[0].message : DEFAULT_ERROR_NAME);
+            this.subscribeWithTimeout(message, (msg) => {
+                console.warn([`Caught error: ${msg}.`, ...logErrors.map((e) => e.getLogMessage())].join('\n'));
+            });
+            this.notify(message, DEFAULT_ERROR_DURATION_MS);
+        };
+    }
+    createErrorOperation(operation, objectName) {
+        return (err) => this.errorOperation(err, operation, objectName);
+    }
+    successOperation(operation, objectName) {
+        let message;
+        switch (operation) {
+            case 'create':
+                message = `${capitalize(objectName)} created successfully`;
+                break;
+            case 'receive':
+                message = `${capitalize(objectName)} received successfully`;
+                break;
+            case 'update':
+                message = `${capitalize(objectName)} updated successfully`;
+                break;
+            case 'delete':
+                message = `${capitalize(objectName)} deleted successfully`;
+                break;
+        }
+        this.success(message);
+    }
+    errorOperation(errors, operation, objectName) {
+        let message;
+        switch (operation) {
+            case 'create':
+                message = `Error creating ${objectName}`;
+                break;
+            case 'receive':
+                message = `Error retrieving ${objectName}`;
+                break;
+            case 'update':
+                message = `Error updating ${objectName}`;
+                break;
+            case 'delete':
+                message = `Error deleting ${objectName}`;
+                break;
+        }
+        this.error(errors, message);
+    }
+    notify(message, duration = DEFAULT_DURATION_MS) {
+        this.subscribeWithTimeout(message, {
+            next: (msg) => {
+                this.snackBar.open(msg, 'OK', {
+                    duration,
+                });
+            },
+            error: () => {
+                // TODO: Default message
+            },
+        });
+    }
+    subscribeWithTimeout(possiblyAsync, subscribe) {
+        getPossiblyAsyncObservable(possiblyAsync)
+            .pipe(first$1(), timeout(DEFAULT_TIMEOUT_MS))
+            .subscribe(subscribe);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NotifyLogService, deps: [{ token: i1$8.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NotifyLogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NotifyLogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1$8.MatSnackBar }] });
+
+class LogModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: LogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: LogModule, imports: [MatSnackBarModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: LogModule, providers: [NotifyLogService], imports: [MatSnackBarModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: LogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [MatSnackBarModule],
+                    providers: [NotifyLogService],
+                }]
+        }] });
+
+const DEFAULT_SIZE = 25;
+class FetchSuperclass {
+    constructor() {
+        this.result$ = defer(() => this.state$).pipe(map$1(({ result }) => result));
+        this.hasMore$ = defer(() => this.state$).pipe(map$1(({ continuationToken }) => !!continuationToken));
+        this.isLoading$ = inProgressFrom(() => this.progress$, () => this.state$);
+        this.fetch$ = new BehaviorSubject({ type: 'init' });
+        this.progress$ = new BehaviorSubject(0);
+        this.state$ = defer(() => {
+            const resAction$ = this.fetch$.pipe(skipWhile((action) => action.type !== 'load'));
+            return race(concat(resAction$.pipe(take(1), delay(1000)), resAction$), resAction$.pipe(skip(1)));
+        }).pipe(tap((action) => {
+            if (action.type === 'load') {
+                this.skipPrevious$.next(true);
+            }
+        }), mergeScan((acc, action) => {
+            const params = (action.type === 'load' ? action.params : acc.params);
+            const size = action.size ?? acc.size;
+            const continuationToken = action.type === 'more' ? acc.continuationToken : undefined;
+            return this.fetch(params, { size, continuationToken }).pipe(...(action.type === 'load'
+                ? [
+                    startWith({
+                        params,
+                        result: [],
+                        size,
+                        continuationToken: undefined,
+                    }),
+                ]
+                : []), map$1(({ result, continuationToken }) => ({
+                params,
+                result: action.type === 'load' || action.type === 'reload'
+                    ? result
+                    : [...(acc.result ?? []), ...result],
+                size,
+                continuationToken,
+            })), progressTo(this.progress$), takeUntil(this.skipPrevious$));
+        }, {
+            size: DEFAULT_SIZE,
+            result: [],
+        }, 1), shareReplay({ bufferSize: 1, refCount: true }));
+        this.skipPrevious$ = new Subject();
+    }
+    load(params, options = {}) {
+        this.fetch$.next({ type: 'load', params, size: options.size });
+    }
+    reload(options = {}) {
+        this.fetch$.next({ type: 'reload', size: options.size });
+    }
+    more() {
+        this.fetch$.next({ type: 'more' });
+    }
+}
+class SingleFetchSuperclass extends FetchSuperclass {
+    constructor() {
+        super(...arguments);
+        this.more = () => undefined;
+    }
+}
+
+const DATE_QUERY_PARAMS_SERIALIZERS = [
+    {
+        id: 'date',
+        serialize: (date) => date?.toISOString(),
+        deserialize: (value) => new Date(value),
+        recognize: (value) => value instanceof Date,
+    },
+    {
+        id: 'dateRange',
+        serialize: ({ start, end }) => `${start?.toISOString()}|${end?.toISOString()}`,
+        deserialize: (value) => {
+            const [start, end] = value.split('|').map((p) => (p ? new Date(p) : null));
+            return { start, end };
+        },
+        recognize: (value) => {
+            if (typeof value !== 'object') {
+                return false;
+            }
+            const { start, end, ...other } = value;
+            if (Object.keys(other).length) {
+                return false;
+            }
+            return start instanceof Date || end instanceof Date;
+        },
+    },
+];
+
+const QUERY_PARAMS_SERIALIZERS = new InjectionToken('query params serializers');
+
+function deserializeQueryParam(value, serializers = []) {
+    const serializer = serializers
+        .sort((a, b) => b.id.length - a.id.length)
+        .find((s) => value.startsWith(s.id));
+    return (serializer
+        ? serializer.deserialize(value.slice(serializer.id.length))
+        : JSON.parse(value || ''));
+}
+
+function serializeQueryParam(value, serializers = []) {
+    const serializer = serializers
+        .sort((a, b) => b.id.length - a.id.length)
+        .find((s) => s.recognize(value));
+    return serializer ? serializer.id + serializer.serialize(value) : JSON.stringify(value);
+}
+
+const NS_PARAM_PREFIX = '__';
+class QueryParamsService {
+    get params() {
+        return this.deserialize(this.getSourceParams().main);
+    }
+    constructor(router, route, serializers) {
+        this.router = router;
+        this.route = route;
+        this.serializers = serializers;
+        this.params$ = defer(() => this.sourceParams$).pipe(map(({ main }) => main), distinctUntilChanged(isEqual), map((params) => this.deserialize(params)), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.sourceParams$ = concat(this.router.events.pipe(startWith(null), skipWhile(() => !this.router.navigated), map(() => this.route.snapshot.queryParams), take(1)), this.route.queryParams).pipe(distinctUntilChanged(isEqual), map((p) => this.getSourceParams(p)), shareReplay({ refCount: true, bufferSize: 1 }));
+        if (!this.serializers) {
+            this.serializers = [];
+        }
+    }
+    async set(params, options = {}) {
+        return await this.setParams(params, undefined, options);
+    }
+    async patch(params, options = {}) {
+        return await this.setParams(params, undefined, { ...options, isPatch: true });
+    }
+    createNamespace(ns) {
+        const getNamespaceSourceParams = (sourceParams = this.getSourceParams()) => sourceParams.namespaces[NS_PARAM_PREFIX + ns];
+        const getNamespaceParams = () => this.deserializeNamespace(getNamespaceSourceParams());
+        return {
+            params$: this.sourceParams$.pipe(map((sourceParams) => getNamespaceSourceParams(sourceParams)), distinctUntilChanged(isEqual), map((params) => this.deserializeNamespace(params)), shareReplay({ refCount: true, bufferSize: 1 })),
+            get params() {
+                return getNamespaceParams();
+            },
+            set: async (params, options = {}) => {
+                return await this.setParams(params, ns, options);
+            },
+            patch: async (params, options = {}) => {
+                return await this.setParams(params, ns, { ...options, isPatch: true });
+            },
+            destroy: async () => {
+                await this.setParams({}, ns);
+            },
+        };
+    }
+    async setParams(params, ns, options = {}) {
+        const sourceParams = this.getSourceParams();
+        let queryParams;
+        if (ns) {
+            const nsKey = NS_PARAM_PREFIX + ns;
+            const serializedNamespace = this.serializeNamespace(Object.assign({}, options.isPatch && this.deserializeNamespace(sourceParams.namespaces[nsKey]), params));
+            const otherNamespaces = sourceParams.namespaces;
+            delete otherNamespaces[nsKey];
+            queryParams = Object.assign({}, sourceParams.main, otherNamespaces, !!serializedNamespace && { [nsKey]: serializedNamespace });
+        }
+        else {
+            queryParams = Object.assign({}, options.isPatch && sourceParams.main, this.serialize(params), sourceParams.namespaces);
+        }
+        return await this.router.navigate([], { queryParams });
+    }
+    getSourceParams(source = this.route.snapshot.queryParams) {
+        return Object.entries(source).reduce((acc, [k, v]) => {
+            if (k.startsWith(NS_PARAM_PREFIX)) {
+                acc.namespaces[k] = v;
+            }
+            else {
+                acc.main[k] = v;
+            }
+            return acc;
+        }, { main: {}, namespaces: {} });
+    }
+    serialize(params, options = {}) {
+        const filter = options.filter ?? negate(isEmpty);
+        return Object.entries(params).reduce((acc, [k, v]) => {
+            if (filter(v, k)) {
+                acc[k] = serializeQueryParam(v, this.serializers);
+            }
+            return acc;
+        }, {});
+    }
+    deserialize(params) {
+        if (!params) {
+            return {};
+        }
+        return Object.entries(params).reduce((acc, [k, v]) => {
+            try {
+                acc[k] = deserializeQueryParam(v, this.serializers);
+            }
+            catch (err) {
+                console.error(err);
+            }
+            return acc;
+        }, {});
+    }
+    serializeNamespace(params) {
+        return params && Object.keys(params).length ? JSON.stringify(params) : '';
+    }
+    deserializeNamespace(strParams) {
+        return strParams ? JSON.parse(strParams) : {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsService, deps: [{ token: i1$6.Router }, { token: i1$6.ActivatedRoute }, { token: QUERY_PARAMS_SERIALIZERS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1$6.Router }, { type: i1$6.ActivatedRoute }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QUERY_PARAMS_SERIALIZERS]
+                }] }] });
+
+class QueryParamsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsModule, providers: [
+            { provide: QUERY_PARAMS_SERIALIZERS, useValue: DATE_QUERY_PARAMS_SERIALIZERS },
+            QueryParamsService,
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: QueryParamsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        { provide: QUERY_PARAMS_SERIALIZERS, useValue: DATE_QUERY_PARAMS_SERIALIZERS },
+                        QueryParamsService,
+                    ],
+                }]
+        }] });
+
+class UrlService {
+    get url() {
+        return this.router.url && this.router.url !== '/'
+            ? this.router.url.split('?', 1)[0].split('#', 1)[0]
+            : window.location.pathname;
+    }
+    get path() {
+        return this.url?.split('/')?.slice(1) ?? [];
+    }
+    constructor(router) {
+        this.router = router;
+        this.url$ = this.router.events.pipe(startWith(null), map(() => this.url), filter((url) => this.router.navigated || (!!url && url !== '/')), distinctUntilChanged(), shareReplay({ refCount: true, bufferSize: 1 }));
+        this.path$ = this.url$.pipe(map(() => this.path), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: UrlService, deps: [{ token: i1$6.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: UrlService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: UrlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$6.Router }] });
+
+function hasExtension(fileName, extensions) {
+    return (!extensions?.length ||
+        new RegExp('(' + extensions.join('|').replace(/\./g, '\\.') + ')$').test(fileName));
+}
+class FileUploadComponent {
+    constructor(log) {
+        this.log = log;
+        this.extensions = [];
+        this.upload = new EventEmitter();
+    }
+    loadFile(event) {
+        const file = event.target?.files?.[0] ?? null;
+        if (!file) {
+            this.log.error(new Error('File upload error'));
+            return;
+        }
+        if (!hasExtension(file.name, this.extensions)) {
+            this.log.error(new Error(`Supported file types: ${this.extensions.join(', ')}`));
+            return;
+        }
+        this.file = file;
+        this.upload.emit(this.file);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FileUploadComponent, deps: [{ token: NotifyLogService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: FileUploadComponent, isStandalone: false, selector: "v-file-upload", inputs: { label: "label", extensions: "extensions" }, outputs: { upload: "upload" }, ngImport: i0, template: "<div class=\"wrapper\">\n    <button mat-button type=\"button\" (click)=\"fileInput.click()\">\n        {{ label ?? 'Choose File' }}\n    </button>\n\n    <div class=\"mat-body-medium mat-secondary-text mat-no-margin\">\n        {{ file?.name }}\n    </div>\n</div>\n\n<input #fileInput hidden type=\"file\" (change)=\"loadFile($event)\" />\n", styles: [".wrapper{display:grid;grid-template-columns:min-content auto;align-items:center;grid-gap:16px}.wrapper>*{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}\n"], dependencies: [{ kind: "component", type: i1$4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FileUploadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-file-upload', standalone: false, template: "<div class=\"wrapper\">\n    <button mat-button type=\"button\" (click)=\"fileInput.click()\">\n        {{ label ?? 'Choose File' }}\n    </button>\n\n    <div class=\"mat-body-medium mat-secondary-text mat-no-margin\">\n        {{ file?.name }}\n    </div>\n</div>\n\n<input #fileInput hidden type=\"file\" (change)=\"loadFile($event)\" />\n", styles: [".wrapper{display:grid;grid-template-columns:min-content auto;align-items:center;grid-gap:16px}.wrapper>*{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}\n"] }]
+        }], ctorParameters: () => [{ type: NotifyLogService }], propDecorators: { label: [{
+                type: Input
+            }], extensions: [{
+                type: Input
+            }], upload: [{
+                type: Output
+            }] } });
+
+class FileUploadModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FileUploadModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: FileUploadModule, declarations: [FileUploadComponent], imports: [CommonModule, MatButtonModule], exports: [FileUploadComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FileUploadModule, imports: [CommonModule, MatButtonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: FileUploadModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FileUploadComponent],
+                    exports: [FileUploadComponent],
+                    imports: [CommonModule, MatButtonModule],
+                }]
+        }] });
+
+function loadFileContent(file, encoding = 'utf-8') {
+    return new Observable((subscriber) => {
+        if (!file) {
+            return undefined;
+        }
+        const read = new FileReader();
+        read.readAsText(file, encoding);
+        read.onloadend = function () {
+            if (read.error) {
+                return subscriber.error(read.error);
+            }
+            else {
+                subscriber.next(read.result || '');
+            }
+            subscriber.complete();
+        };
+    });
+}
+
+class DatetimeFieldComponent extends FormComponentSuperclass$1 {
+    constructor() {
+        super(...arguments);
+        this.required = false;
+    }
+    get time() {
+        return this.datetime ? format(this.datetime, 'HH:mm') : '';
+    }
+    handleIncomingValue(value) {
+        this.datetime = value ? createDateFromNoTimeZoneString(value) : null;
+    }
+    timeChanged(event) {
+        const [hours, minutes] = event.target.value.split(':');
+        if (!this.datetime) {
+            this.datetime = new Date();
+        }
+        this.datetime.setHours(Number(hours));
+        this.datetime.setMinutes(Number(minutes));
+        this.datetime.setSeconds(0);
+        this.datetime.setMilliseconds(0);
+        this.emitValue();
+    }
+    dateChanged(date) {
+        const v = date.target.value || new Date();
+        if (this.datetime) {
+            this.datetime.setDate(v.getDate());
+            this.datetime.setMonth(v.getMonth());
+            this.datetime.setFullYear(v.getFullYear());
+        }
+        else {
+            this.datetime = v;
+        }
+        this.emitValue();
+    }
+    validate() {
+        return !this.datetime || isValid(this.datetime) ? null : { invalidDatetime: true };
+    }
+    emitValue() {
+        return this.emitOutgoingValue(getNoTimeZoneIsoString(this.datetime));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: DatetimeFieldComponent, isStandalone: false, selector: "v-datetime-field", inputs: { label: "label", required: ["required", "required", booleanAttribute], hint: "hint" }, providers: [
+            ...createControlProviders(() => DatetimeFieldComponent),
+            { provide: MAT_DATE_LOCALE, useValue: enGB },
+            { provide: DateAdapter, useClass: DateFnsAdapter, deps: [MAT_DATE_LOCALE] },
+            { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS },
+        ], usesInheritance: true, ngImport: i0, template: "<div class=\"wrapper\">\n    <mat-form-field class=\"date\">\n        <mat-label>\n            {{ label }}\n        </mat-label>\n        <mat-hint>{{ hint }}</mat-hint>\n        <input\n            [matDatepicker]=\"picker\"\n            [required]=\"required\"\n            [value]=\"datetime\"\n            matInput\n            (dateInput)=\"dateChanged($event)\"\n        />\n        <mat-datepicker-toggle [for]=\"picker\" matSuffix></mat-datepicker-toggle>\n        <mat-datepicker #picker></mat-datepicker>\n    </mat-form-field>\n    @if (datetime) {\n        <mat-form-field class=\"time\">\n            <input [value]=\"time\" matInput type=\"time\" (input)=\"timeChanged($event)\" />\n        </mat-form-field>\n    }\n</div>\n", styles: [".wrapper{display:flex;gap:8px}.wrapper .date{flex:1}.wrapper .time{width:100px}\n"], dependencies: [{ kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i3.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "directive", type: i2$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "component", type: i2$7.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i2$7.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { kind: "component", type: i2$7.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-datetime-field', providers: [
+                        ...createControlProviders(() => DatetimeFieldComponent),
+                        { provide: MAT_DATE_LOCALE, useValue: enGB },
+                        { provide: DateAdapter, useClass: DateFnsAdapter, deps: [MAT_DATE_LOCALE] },
+                        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS },
+                    ], standalone: false, template: "<div class=\"wrapper\">\n    <mat-form-field class=\"date\">\n        <mat-label>\n            {{ label }}\n        </mat-label>\n        <mat-hint>{{ hint }}</mat-hint>\n        <input\n            [matDatepicker]=\"picker\"\n            [required]=\"required\"\n            [value]=\"datetime\"\n            matInput\n            (dateInput)=\"dateChanged($event)\"\n        />\n        <mat-datepicker-toggle [for]=\"picker\" matSuffix></mat-datepicker-toggle>\n        <mat-datepicker #picker></mat-datepicker>\n    </mat-form-field>\n    @if (datetime) {\n        <mat-form-field class=\"time\">\n            <input [value]=\"time\" matInput type=\"time\" (input)=\"timeChanged($event)\" />\n        </mat-form-field>\n    }\n</div>\n", styles: [".wrapper{display:flex;gap:8px}.wrapper .date{flex:1}.wrapper .time{width:100px}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hint: [{
+                type: Input
+            }] } });
+
+class DatetimeFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldModule, declarations: [DatetimeFieldComponent], imports: [CommonModule, MatFormFieldModule, MatInputModule, MatDatepickerModule], exports: [DatetimeFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldModule, imports: [CommonModule, MatFormFieldModule, MatInputModule, MatDatepickerModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: DatetimeFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DatetimeFieldComponent],
+                    exports: [DatetimeFieldComponent],
+                    imports: [CommonModule, MatFormFieldModule, MatInputModule, MatDatepickerModule],
+                }]
+        }] });
+
+class SwitchButtonComponent extends FormControlSuperclass {
+    constructor() {
+        super(...arguments);
+        this.states = [];
+        this.hasChangeValue = false;
+    }
+    get index() {
+        return this.getIndex(this.control.value);
+    }
+    get nextIndex() {
+        const nextIdx = this.index + 1;
+        return nextIdx === this.states.length ? 0 : nextIdx;
+    }
+    get value() {
+        return this.getValue(this.getIndex(this.control.value));
+    }
+    get state() {
+        return this.states[this.index];
+    }
+    get nextState() {
+        return this.states[this.nextIndex];
+    }
+    get tooltip() {
+        const nextState = this.states[this.nextIndex];
+        return nextState.label ? `Switch to ${lowerFirst(nextState.label)}` : '';
+    }
+    change() {
+        this.control.setValue(this.getValue(this.nextIndex));
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        if (changes.states && this.states.length) {
+            if (!isNil(this.states?.[0]?.value)) {
+                this.hasChangeValue = true;
+            }
+            if (isNil(this.control.value)) {
+                this.control.setValue(this.value);
+            }
+        }
+    }
+    getIndex(value) {
+        return ((this.hasChangeValue
+            ? this.states.findIndex((s) => s.value === value)
+            : value) ?? 0);
+    }
+    getValue(index) {
+        return this.hasChangeValue ? this.states[index]?.value : index;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.2", type: SwitchButtonComponent, isStandalone: false, selector: "v-switch-button", inputs: { states: "states" }, providers: createControlProviders(() => SwitchButtonComponent), usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<button [matTooltip]=\"tooltip\" class=\"button\" mat-icon-button (click)=\"change()\">\n    <mat-icon class=\"icon\">{{ state?.icon }}</mat-icon>\n</button>\n", dependencies: [{ kind: "component", type: i1$4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i2$5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-switch-button', providers: createControlProviders(() => SwitchButtonComponent), standalone: false, template: "<button [matTooltip]=\"tooltip\" class=\"button\" mat-icon-button (click)=\"change()\">\n    <mat-icon class=\"icon\">{{ state?.icon }}</mat-icon>\n</button>\n" }]
+        }], propDecorators: { states: [{
+                type: Input
+            }] } });
+
+class SwitchButtonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonModule, declarations: [SwitchButtonComponent], imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule], exports: [SwitchButtonComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonModule, imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: SwitchButtonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SwitchButtonComponent],
+                    imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule],
+                    exports: [SwitchButtonComponent],
+                }]
+        }] });
+
+class NavComponent {
+    constructor(urlService) {
+        this.urlService = urlService;
+        this.type = input();
+        this.links = input([], {
+            transform: (v) => (isArray(v[0]) ? v : [v]),
+        });
+        this.exact = input(false, { transform: booleanAttribute });
+        this.activeLink$ = combineLatest([
+            this.urlService.url$,
+            toObservable(this.links),
+            toObservable(this.exact),
+        ]).pipe(map(([url, links, exact]) => links.flat().reduce((res, link) => {
+            const index = url.indexOf(link.url);
+            if (index !== -1 && (exact ? index === 0 : index < res.index)) {
+                return { index, link };
+            }
+            return res;
+        }, { index: Infinity, link: null })?.link), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NavComponent, deps: [{ token: UrlService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.2", type: NavComponent, isStandalone: true, selector: "v-nav", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null }, links: { classPropertyName: "links", publicName: "links", isSignal: true, isRequired: false, transformFunction: null }, exact: { classPropertyName: "exact", publicName: "exact", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<div [ngClass]=\"{ 'v-nav__secondary': type() === 'secondary' }\" class=\"v-nav\">\n    @for (linksGroup of links(); track linksGroup; let index = $index) {\n        @if (index !== 0) {\n            <mat-divider></mat-divider>\n        }\n        @for (link of linksGroup; track link) {\n            <div\n                [ngClass]=\"{ item__active: (activeLink$ | async) === link }\"\n                [routerLink]=\"link.url\"\n                [title]=\"link.label\"\n                class=\"mat-body-large item mat-no-margin\"\n            >\n                {{ link.label }}\n            </div>\n        }\n    }\n</div>\n", styles: [".v-nav{display:flex;flex-direction:column}.v-nav .item{cursor:pointer;padding:12px 24px 12px 12px}.v-nav .item__active{font-weight:500}.v-nav .item:after{display:block;content:attr(title);font-weight:500;height:0;color:transparent;overflow:hidden;visibility:hidden}.v-nav__secondary .item{border-left:solid 4px}\n"], dependencies: [{ kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "component", type: MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: NavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'v-nav', imports: [RouterLink, NgClass, AsyncPipe, MatDivider], encapsulation: ViewEncapsulation.None, template: "<div [ngClass]=\"{ 'v-nav__secondary': type() === 'secondary' }\" class=\"v-nav\">\n    @for (linksGroup of links(); track linksGroup; let index = $index) {\n        @if (index !== 0) {\n            <mat-divider></mat-divider>\n        }\n        @for (link of linksGroup; track link) {\n            <div\n                [ngClass]=\"{ item__active: (activeLink$ | async) === link }\"\n                [routerLink]=\"link.url\"\n                [title]=\"link.label\"\n                class=\"mat-body-large item mat-no-margin\"\n            >\n                {{ link.label }}\n            </div>\n        }\n    }\n</div>\n", styles: [".v-nav{display:flex;flex-direction:column}.v-nav .item{cursor:pointer;padding:12px 24px 12px 12px}.v-nav .item__active{font-weight:500}.v-nav .item:after{display:block;content:attr(title);font-weight:500;height:0;color:transparent;overflow:hidden;visibility:hidden}.v-nav__secondary .item{border-left:solid 4px}\n"] }]
+        }], ctorParameters: () => [{ type: UrlService }] });
+
+class AmountCurrencyPipe {
+    constructor(_locale, _defaultCurrencyCode = 'USD') {
+        this._locale = _locale;
+        this._defaultCurrencyCode = _defaultCurrencyCode;
+    }
+    transform(amount, currencyCode = this._defaultCurrencyCode, format = 'long', exponent, isMajor = false) {
+        if (typeof amount === 'number') {
+            return formatCurrency(amount, currencyCode, format, this._locale, exponent, isMajor);
+        }
+        return amount;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AmountCurrencyPipe, deps: [{ token: LOCALE_ID }, { token: DEFAULT_CURRENCY_CODE }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: AmountCurrencyPipe, isStandalone: true, name: "amountCurrency" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: AmountCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'amountCurrency',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DEFAULT_CURRENCY_CODE]
+                }] }] });
+
+class EnumKeyValuesPipe {
+    transform(value) {
+        return getEnumKeyValues(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyValuesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyValuesPipe, isStandalone: true, name: "enumKeyValues" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyValuesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'enumKeyValues',
+                }]
+        }] });
+
+class EnumKeyPipe {
+    transform(value, enumObj) {
+        return !isNil(value) && enumObj ? getEnumKey(enumObj, value) : '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyPipe, isStandalone: true, name: "enumKey" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'enumKey',
+                }]
+        }] });
+
+class EnumKeysPipe {
+    transform(value) {
+        return getEnumKeys(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeysPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: EnumKeysPipe, isStandalone: true, name: "enumKeys" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: EnumKeysPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'enumKeys',
+                }]
+        }] });
+
+const DEFAULT_TIMER = 7500;
+class HumanizedDurationPipe extends AsyncTransform {
+    constructor() {
+        super(...arguments);
+        this.result$ = combineLatest([this.params$, timer(0, DEFAULT_TIMER)]).pipe(throttleTime(DEFAULT_TIMER), map(([[value, config]]) => formatDistanceToNow(new Date(value), { includeSeconds: true }) +
+            (config.hasAgoEnding ? ' ago' : '')), distinctUntilChanged());
+    }
+    transform(...params) {
+        return super.asyncTransform(params);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: HumanizedDurationPipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: HumanizedDurationPipe, isStandalone: true, name: "humanizedDuration", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: HumanizedDurationPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'humanizedDuration',
+                    pure: false,
+                }]
+        }] });
+
+class InlineJsonPipe {
+    transform(value, maxReadableLever = 1) {
+        return inlineJson(value, maxReadableLever === false ? Infinity : maxReadableLever);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InlineJsonPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: InlineJsonPipe, isStandalone: false, name: "inlineJson" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: InlineJsonPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'inlineJson',
+                    standalone: false,
+                }]
+        }] });
+
+class VSelectPipe {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    transform(obj, selectFn, defaultValue, rest = []) {
+        const res = obj && selectFn ? select(obj, selectFn, defaultValue, rest) : null;
+        if (isObservable(res) && !this.asyncPipe) {
+            this.asyncPipe = new AsyncPipe(this.ref);
+        }
+        if (this.asyncPipe) {
+            return this.asyncPipe.transform(res);
+        }
+        return res;
+    }
+    ngOnDestroy() {
+        this.asyncPipe?.ngOnDestroy?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: VSelectPipe, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: VSelectPipe, isStandalone: true, name: "vSelect", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: VSelectPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    standalone: true,
+                    name: 'vSelect',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+
+class PipesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: PipesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.2", ngImport: i0, type: PipesModule, declarations: [InlineJsonPipe], imports: [CommonModule,
+            EnumKeyPipe,
+            EnumKeysPipe,
+            EnumKeyValuesPipe,
+            AmountCurrencyPipe,
+            VSelectPipe,
+            HumanizedDurationPipe], exports: [InlineJsonPipe,
+            EnumKeyPipe,
+            EnumKeysPipe,
+            EnumKeyValuesPipe,
+            AmountCurrencyPipe,
+            VSelectPipe,
+            HumanizedDurationPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: PipesModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImport: i0, type: PipesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [InlineJsonPipe],
+                    exports: [
+                        InlineJsonPipe,
+                        EnumKeyPipe,
+                        EnumKeysPipe,
+                        EnumKeyValuesPipe,
+                        AmountCurrencyPipe,
+                        VSelectPipe,
+                        HumanizedDurationPipe,
+                    ],
+                    imports: [
+                        CommonModule,
+                        EnumKeyPipe,
+                        EnumKeysPipe,
+                        EnumKeyValuesPipe,
+                        AmountCurrencyPipe,
+                        VSelectPipe,
+                        HumanizedDurationPipe,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActionsComponent, ActionsModule, AmountCurrencyPipe, AsyncTransform, AutocompleteFieldComponent, AutocompleteFieldModule, BASE_CONFIG, ConfigServiceSuperclass, ConfirmDialogComponent, ConfirmDialogModule, ContentLoadingComponent, DATE_QUERY_PARAMS_SERIALIZERS, DEFAULT_DIALOG_CONFIG, DEFAULT_DIALOG_CONFIG_FULL_HEIGHT, DIALOG_CONFIG, DateRangeFieldComponent, DateRangeFieldModule, DatetimeFieldComponent, DatetimeFieldModule, DebounceTime, DialogActionsComponent, DialogComponent, DialogModule, DialogResponseStatus, DialogService, DialogSuperclass, EnumKeyPipe, EnumKeyValuesPipe, EnumKeysPipe, ErrorPageComponent, ErrorPageModule, FetchSuperclass, FileUploadComponent, FileUploadModule, FiltersComponent, FiltersModule, FormComponentSuperclass, FormControlSuperclass, FormGroupSuperclass, HighlightDirective, HumanizedDurationPipe, InlineJsonPipe, InputFieldComponent, InputFieldModule, ListFieldComponent, ListFieldModule, LogModule, MainFiltersDirective, MoreFiltersButtonComponent, NavComponent, NormColumn, NotifyLogService, NumberRangeFieldComponent, NumberRangeFieldModule, OtherFiltersDirective, PipesModule, QUERY_PARAMS_SERIALIZERS, QueryParamsModule, QueryParamsService, SelectFieldComponent, SelectFieldModule, SingleFetchSuperclass, SwitchButtonComponent, SwitchButtonModule, TableActionsComponent, TableComponent, TableInputsComponent, TableModule, TagComponent, TagModule, UrlService, VSelectPipe, ValueComponent, ValueListComponent, arrayAttribute, asyncStartWith, cachedHeadMap, clean, cleanPrimitiveProps, compareDifferentTypes, correctPriorities, countChanged, countProps, createColumn, createControlProviders, createControls, createCsv, createDateFromNoTimeZoneString, createDateRangeToToday, createMenuColumn, createStorageValue, debounceTimeWithFirst, downloadFile, enumHasValue, forkJoinToResult, formatCurrency, getCurrencyExponent, getEnumEntries, getEnumKey, getEnumKeyValues, getEnumKeys, getEnumValues, getErrorsTree, getImportValue, getNoTimeZoneIsoString, getPossiblyAsyncObservable, getValidValueChanges, getValue$1 as getValue, getValueChanges, handleError, hasControls, inProgressFrom, inlineJson, isAsync, isEmpty, isEmptyPrimitive, isEqualDateRange, isResultsHasError, loadFileContent, normalizeCell, normalizePossiblyFn, parseCsv, passError, progressTo, select, setDisabled, splitBySeparators, splitResultsErrors, switchCombineWith, toMajor, toMajorByExponent, toMinor, toMinorByExponent, treeDataItemToInlineDataItem, unifyCsvItems };
+//# sourceMappingURL=vality-matez.mjs.map