@devopmaat/badaboom 1.3.7 → 1.3.9

package/index.d.ts

@@ -1,5 +1,1231 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, TemplateRef, Type, PipeTransform, EventEmitter, QueryList, OnInit, OnDestroy, AfterViewInit, ElementRef, OnChanges, AfterContentInit, TrackByFunction, Renderer2 } from '@angular/core';
+import { Routes, Router, ActivatedRoute, CanActivateFn, ResolveFn } from '@angular/router';
+import { DataSource, SelectionModel, CollectionViewer, ListRange } from '@angular/cdk/collections';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import { HttpClient, HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
+import { PageEvent } from '@angular/material/paginator';
+import { FormControl, ControlContainer, ControlValueAccessor, NgControl, AbstractControl, FormGroup, ValidatorFn } from '@angular/forms';
+import { MatAutocompleteTrigger, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { MatIconButton } from '@angular/material/button';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { Sort } from '@angular/material/sort';
+import * as _devopmaat_badaboom from '@devopmaat/badaboom';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatDialog } from '@angular/material/dialog';
+
+interface BdbAuthOptions {
+    loginPath: string;
+    logoutPath: string;
+    accessDeniedPath: string;
+    forgotPasswordPath: string;
+    resetPasswordPath: string;
+    invalidTokenPath: string;
+    addPresentation: boolean;
+}
+declare class BdbAuthOptionsBuilder {
+    private _loginPath?;
+    private _logoutPath?;
+    private _accessDeniedPath?;
+    private _forgotPasswordPath?;
+    private _resetPasswordPath?;
+    private _invalidTokenPath?;
+    private _addPresentation;
+    constructor(configure: BdbAuthOptionsConfigure);
+    set loginPath(path: string);
+    set logoutPath(path: string);
+    set accessDeniedPath(path: string);
+    set forgotPasswordPath(path: string);
+    set resetPasswordPath(path: string);
+    set invalidTokenPath(path: string);
+    addPresentation(): void;
+    build(): BdbAuthOptions;
+}
+type BdbAuthOptionsConfigure = (_: BdbAuthOptionsBuilder) => void;
+
+interface BdbOptions {
+    backendUrl: string;
+    mediaUrl: string;
+    authOptions?: BdbAuthOptions;
+}
+declare class BdbOptionsBuilder {
+    private _backendUrl;
+    private _mediaUrl;
+    private _auth?;
+    constructor(configure: BdbOptionsConfigure);
+    set backendUrl(url: string);
+    set mediaUrl(url: string);
+    addAuth(configure: BdbAuthOptionsConfigure): void;
+    build(): BdbOptions;
+}
+type BdbOptionsConfigure = (_: BdbOptionsBuilder) => void;
+declare const BDB_OPTIONS: InjectionToken<BdbOptions>;
+
 /**
- * Generated bundle index. Do not edit.
+ * Configures BaDaBoom by providing necessary tokens.
+ * Takes root routes and provides the router with these routes, appending routes if specified
+ * @param {BdbOptionsConfigure} optionsConfigure
+ * @param {Routes} routes
+ * @return {EnvironmentProviders}
  */
-/// <amd-module name="@devopmaat/badaboom" />
-export * from './public-api';
+declare function provideBaDaBoom(optionsConfigure: BdbOptionsConfigure, routes: Routes): EnvironmentProviders;
+
+interface BdbEntityRead {
+    id: number;
+}
+
+interface BdbResponse<T> {
+    page: number;
+    pageSize: number;
+    rows: T[];
+    count: number;
+}
+
+interface BdbFilter {
+    type: 'Field' | 'Group';
+    field?: string;
+    operator?: 'Equals' | 'IsNull' | 'IsEmpty' | 'StartsWith' | 'Contains' | 'EndsWith' | 'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual';
+    parameters?: unknown[];
+    filters?: BdbFilter[];
+    combine?: 'And' | 'Or';
+    negate?: boolean;
+}
+
+interface BdbRequest {
+    page?: number;
+    pageSize?: number;
+    sortField?: string;
+    sortDirection?: '' | 'asc' | 'desc';
+    query?: string;
+    baseFilter?: string;
+    filter?: BdbFilter;
+}
+
+interface BdbEntity {
+    id: number;
+}
+
+declare abstract class BdbService {
+    baseUrl: string;
+    httpClient: HttpClient;
+    constructor(areaName: string);
+}
+
+declare abstract class BdbServiceR<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead> extends BdbService {
+    read(request: BdbRequest): Observable<BdbResponse<TEntityRead>>;
+    get(id: number): Observable<TEntity>;
+}
+
+declare class BdbDataSource<TEntityRead extends BdbEntityRead> implements DataSource<TEntityRead> {
+    private service;
+    dataSubject: BehaviorSubject<TEntityRead[]>;
+    private responseSubject;
+    private loadingSubject;
+    private errorSubject;
+    loading$: Observable<boolean>;
+    error$: Observable<HttpErrorResponse | null>;
+    response$: Observable<BdbResponse<TEntityRead>>;
+    readonly request: BdbRequest;
+    get data(): TEntityRead[];
+    constructor(service: BdbServiceR<BdbEntity, TEntityRead>, initialRequest?: BdbRequest);
+    disconnect(): void;
+    connect(): Observable<TEntityRead[] | readonly TEntityRead[]>;
+    loadMethod(service: BdbServiceR<BdbEntity, TEntityRead>, request: BdbRequest): Observable<BdbResponse<TEntityRead>>;
+    load(): void;
+}
+
+declare enum BdbColumnType {
+    String = "String",
+    Number = "Number",
+    Percentage = "Percentage",
+    Currency = "Currency",
+    Date = "Date",
+    Boolean = "Boolean",
+    Enum = "Enum",
+    Custom = "Custom"
+}
+
+interface BdbColumn<TRead, TField> {
+    template?: TemplateRef<never> | undefined;
+    field: (x: TRead) => TField;
+    type: BdbColumnType;
+    id: string;
+    title: string;
+    sortDisabled?: boolean;
+    width?: number;
+    textAlign?: 'start' | 'end';
+    format?: string;
+    icon?: boolean;
+    pipe?: Type<PipeTransform>;
+    currencyCode?: string;
+    display?: string;
+    digitsInfo?: string;
+    locale?: string;
+}
+
+interface BdbContextAction<TRead> {
+    icon: string;
+    color: string;
+    label: string;
+    identifier: string;
+    condition?: (x: TRead) => boolean;
+}
+
+type BdbPalette = 'primary' | 'accent' | 'danger' | 'warn' | 'success' | 'info' | undefined;
+type BdbM3Palette = 'primary' | 'secondary' | 'tertiary' | 'error' | 'warn' | 'success' | 'info' | undefined;
+
+declare class BdbCellDirective {
+    templateRef: TemplateRef<never>;
+    bdbCellDef: string;
+    constructor(templateRef: TemplateRef<never>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbCellDirective, "ng-template[bdbCellDef]", never, { "bdbCellDef": { "alias": "bdbCellDef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbFullTableComponent<TEntityRead extends BdbEntity> {
+    dataSource: BdbDataSource<TEntityRead>;
+    columns: BdbColumn<TEntityRead, unknown>[];
+    displayedColumns: string[];
+    autoLoad?: boolean;
+    selection?: SelectionModel<TEntityRead>;
+    contextActions: BdbContextAction<TEntityRead>[];
+    rowColor?: (x: TEntityRead) => BdbM3Palette;
+    showToolbar: boolean;
+    rowClick: EventEmitter<TEntityRead>;
+    contextAction: EventEmitter<{
+        action: BdbContextAction<TEntityRead>;
+        row: TEntityRead;
+    }>;
+    cellTemplates: QueryList<BdbCellDirective> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbFullTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbFullTableComponent<any>, "bdb-full-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; "rowColor": { "alias": "rowColor"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; }, { "rowClick": "rowClick"; "contextAction": "contextAction"; }, ["cellTemplates"], ["toolbar-item"], true, never>;
+}
+
+declare class BdbPaginatorComponent<TEntityRead extends BdbEntityRead> implements OnInit, OnDestroy {
+    dataSource: BdbDataSource<TEntityRead>;
+    private _onDestroy;
+    pageSize?: number;
+    page?: number;
+    length?: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    changePage(event: PageEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbPaginatorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbPaginatorComponent<any>, "bdb-paginator", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbQueryInputComponent<TEntityRead extends BdbEntityRead> implements OnInit, OnDestroy {
+    class: string;
+    dataSource: BdbDataSource<TEntityRead>;
+    private _onDestroy;
+    queryFormControl: FormControl<string | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbQueryInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbQueryInputComponent<any>, "bdb-query-input[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class BdbSearchWrapperBaseComponent<TEntityRead extends BdbEntityRead> implements OnInit {
+    controlName?: string;
+    control?: FormControl<TEntityRead | null>;
+    formControl: FormControl<TEntityRead | null>;
+    controlContainer: ControlContainer;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbSearchWrapperBaseComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbSearchWrapperBaseComponent<any>, "ng-component", never, { "controlName": { "alias": "controlName"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbSearchComponent<TEntityRead extends BdbEntityRead> implements CollectionViewer, OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    ngControl: NgControl;
+    dataSource: BdbDataSource<TEntityRead>;
+    displayFn: (_: TEntityRead | string) => string;
+    label: string;
+    hint: string;
+    placeholder: string;
+    searchInput?: ElementRef<HTMLInputElement>;
+    clearButton?: MatIconButton;
+    autoCompleteTrigger?: MatAutocompleteTrigger;
+    private readonly _onDestroy;
+    viewChange: BehaviorSubject<ListRange>;
+    searchOptions?: Observable<TEntityRead[] | readonly TEntityRead[]>;
+    searchCtrl: FormControl<string | TEntityRead>;
+    inputTabIndex: number;
+    hasValue: boolean;
+    isDisabled: boolean;
+    onChange?: (_: TEntityRead | null) => void;
+    onTouch?: () => void;
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(obj: TEntityRead | null): void;
+    registerOnChange(fn: (_: TEntityRead | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    selectOption(event: MatAutocompleteSelectedEvent): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbSearchComponent<any>, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbSearchComponent<any>, "bdb-search", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayFn": { "alias": "displayFn"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface BdbColumnOptions {
+    id?: string;
+    sortDisabled?: boolean;
+    width?: number;
+    textAlign?: 'start' | 'end';
+}
+interface BdbBooleanColumnOptions extends BdbColumnOptions {
+    icon?: boolean;
+}
+interface BdbDateColumnOptions extends BdbColumnOptions {
+    format?: string;
+}
+interface BdbEnumColumnOptions extends BdbColumnOptions {
+    pipe?: Type<PipeTransform>;
+}
+interface BdbNumberColumnOptions extends BdbColumnOptions {
+    pipe?: Type<PipeTransform>;
+    format?: string;
+}
+interface BdbPercentageColumnOptions extends BdbColumnOptions {
+    digitsInfo?: string;
+    locale?: string;
+}
+interface BdbCurrencyColumnOptions extends BdbColumnOptions {
+    currencyCode?: string;
+    display?: string;
+    digitsInfo?: string;
+    locale?: string;
+}
+interface BdbStringColumnOptions extends BdbColumnOptions {
+    pipe?: Type<PipeTransform>;
+}
+
+declare class BdbColumnBuilder<TRead extends BdbEntityRead> {
+    build(...columns: BdbColumn<TRead, unknown>[]): BdbColumn<TRead, unknown>[];
+    string(field: (x: TRead) => string | undefined, title: string, options?: BdbStringColumnOptions): BdbColumn<TRead, string | undefined>;
+    number(field: (x: TRead) => number | undefined, title: string, options?: BdbNumberColumnOptions): BdbColumn<TRead, number | undefined>;
+    percentage(field: (x: TRead) => number | undefined, title: string, options?: BdbPercentageColumnOptions): BdbColumn<TRead, number | undefined>;
+    currency(field: (x: TRead) => number | undefined, title: string, options?: BdbCurrencyColumnOptions): BdbColumn<TRead, number | undefined>;
+    date(field: (x: TRead) => Date | undefined, title: string, options?: BdbDateColumnOptions): BdbColumn<TRead, Date | undefined>;
+    boolean(field: (x: TRead) => boolean | undefined, title: string, options?: BdbBooleanColumnOptions): BdbColumn<TRead, boolean | undefined>;
+    enum<TEnum>(field: (x: TRead) => TEnum | undefined, title: string, options?: BdbEnumColumnOptions): BdbColumn<TRead, TEnum | undefined>;
+    custom(id: string, title: string, options?: BdbColumnOptions): BdbColumn<TRead, unknown>;
+    private _buildCommonOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbColumnBuilder<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BdbColumnBuilder<any>>;
+}
+
+declare class BdbTableComponent<TRead extends BdbEntity> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+    private readonly _onDestroy;
+    columns: BdbColumn<TRead, unknown>[];
+    dataSource: BdbDataSource<TRead>;
+    autoLoad?: boolean;
+    displayedColumns: string[];
+    contextActions: BdbContextAction<TRead>[];
+    selection?: SelectionModel<TRead>;
+    selectOnRowClick: boolean;
+    selectedRowClass: string;
+    isClickable: boolean;
+    rowClick: EventEmitter<TRead>;
+    contextAction: EventEmitter<{
+        action: BdbContextAction<TRead>;
+        row: TRead;
+    }>;
+    contextMenu: MatMenuTrigger;
+    cellTemplates: QueryList<BdbCellDirective> | undefined;
+    error: HttpErrorResponse | undefined;
+    columnType: typeof BdbColumnType;
+    contextMenuPosition: {
+        x: string;
+        y: string;
+    };
+    rowColor?: (x: TRead) => BdbM3Palette;
+    trackById: TrackByFunction<BdbEntity>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    load(): void;
+    setColumnTemplates(): void;
+    onRowClick(row: TRead): void;
+    sortData(event: Sort): void;
+    onContextMenu(event: MouseEvent, row: TRead): void;
+    onContextMenuAction(action: BdbContextAction<TRead>, row: TRead): void;
+    isAllSelected(): boolean;
+    anySelected(): boolean;
+    toggleAllRows(): void;
+    rowClass(row: TRead): {
+        [klass: string]: unknown;
+    } | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbTableComponent<any>, "bdb-table[dataSource]", never, { "columns": { "alias": "columns"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "selectOnRowClick": { "alias": "selectOnRowClick"; "required": false; }; "selectedRowClass": { "alias": "selectedRowClass"; "required": false; }; "isClickable": { "alias": "isClickable"; "required": false; }; "rowColor": { "alias": "rowColor"; "required": false; }; }, { "rowClick": "rowClick"; "contextAction": "contextAction"; }, ["cellTemplates"], ["*"], true, never>;
+}
+
+interface ExceptionLogRead extends BdbEntityRead {
+    code: string;
+    message: string;
+    description: string;
+    type: string;
+    created: Date;
+    createdBy: string;
+}
+
+declare class ExceptionLogTableComponent {
+    private cb;
+    private router;
+    private activatedRoute;
+    dataSource: BdbDataSource<ExceptionLogRead>;
+    displayedColumns: string[];
+    rowClick: EventEmitter<ExceptionLogRead>;
+    columns: BdbColumn<ExceptionLogRead, unknown>[];
+    constructor(cb: BdbColumnBuilder<ExceptionLogRead>, router: Router, activatedRoute: ActivatedRoute);
+    contextActions: BdbContextAction<ExceptionLogRead>[];
+    onRowClick(row: ExceptionLogRead): void;
+    onContextAction(event: {
+        action: BdbContextAction<ExceptionLogRead>;
+        row: ExceptionLogRead;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExceptionLogTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExceptionLogTableComponent, "bdb-exception-log-table[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "rowClick": "rowClick"; }, never, never, true, never>;
+}
+
+declare enum MediaType {
+    Image = "Image",
+    Video = "Video",
+    File = "File"
+}
+declare const MediaTypeMap: Map<MediaType, string>;
+
+interface MediaPreview extends BdbEntity {
+    fileName: string;
+    height: number;
+    width: number;
+}
+
+interface Media extends BdbEntity {
+    fileName?: string;
+    fileSize?: number;
+    height?: number;
+    preview?: MediaPreview;
+    reference?: string;
+    type: MediaType;
+    width?: number;
+    originalFileName?: string;
+}
+
+declare class BdbMediaDisplayComponent implements OnChanges {
+    media?: Media;
+    mode: 'preview' | 'live' | 'details';
+    overlayBehavior: 'hover' | 'always';
+    width?: number;
+    height?: number;
+    alt?: string;
+    bdbOptions: _devopmaat_badaboom.BdbOptions;
+    class: string;
+    src?: string;
+    mediaType: typeof MediaType;
+    hasError: boolean;
+    noMediaUrl?: string;
+    ngOnChanges(): void;
+    getSource(media?: Media, download?: boolean): string | undefined;
+    getDownloadUrl(): string | undefined;
+    getFileExtension(fileName: string): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbMediaDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbMediaDisplayComponent, "bdb-media-display", never, { "media": { "alias": "media"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "overlayBehavior": { "alias": "overlayBehavior"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MediaFullTableComponent {
+    dataSource: BdbDataSource<Media>;
+    displayedColumns: string[];
+    selection?: SelectionModel<Media>;
+    showToolbar: boolean;
+    contextActions: BdbContextAction<Media>[];
+    contextAction: EventEmitter<{
+        action: BdbContextAction<Media>;
+        row: Media;
+    }>;
+    rowClick: EventEmitter<Media>;
+    cb: BdbColumnBuilder<Media>;
+    columns: BdbColumn<Media, unknown>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaFullTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MediaFullTableComponent, "bdb-media-full-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "contextAction": "contextAction"; "rowClick": "rowClick"; }, never, ["toolbar-item", "*"], true, never>;
+}
+
+declare class BdbMediaInputComponent implements ControlValueAccessor, MatFormFieldControl<Media | undefined>, OnDestroy {
+    ngControl: NgControl;
+    class: string;
+    clearOnDragOver: boolean;
+    mediaType: typeof MediaType;
+    stateChanges: Subject<void>;
+    private _value?;
+    touched: boolean;
+    set value(value: Media | undefined);
+    get value(): Media | undefined;
+    ngOnDestroy(): void;
+    static nextId: number;
+    id: string;
+    get placeholder(): string;
+    set placeholder(plh: string);
+    private _placeholder;
+    error?: HttpErrorResponse;
+    constructor(ngControl: NgControl);
+    ngAfterViewInit(): void;
+    focused: boolean;
+    onFocusIn(event: FocusEvent): void;
+    onFocusOut(event: FocusEvent): void;
+    get empty(): boolean;
+    shouldLabelFloat: boolean;
+    get required(): boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    get errorState(): boolean;
+    controlType: string;
+    userAriaDescribedBy?: string;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    isDisabled: boolean;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: Media | undefined): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onUploadComplete($event: Media): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbMediaInputComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbMediaInputComponent, "bdb-media-input", never, { "clearOnDragOver": { "alias": "clearOnDragOver"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MediaTableComponent {
+    dataSource: BdbDataSource<Media>;
+    displayedColumns: string[];
+    contextActions: BdbContextAction<Media>[];
+    contextAction: EventEmitter<{
+        action: BdbContextAction<Media>;
+        row: Media;
+    }>;
+    rowClick: EventEmitter<Media>;
+    cb: BdbColumnBuilder<Media>;
+    columns: BdbColumn<Media, unknown>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MediaTableComponent, "bdb-media-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "contextAction": "contextAction"; "rowClick": "rowClick"; }, never, never, true, never>;
+}
+
+declare class MediaTypeIconPipe implements PipeTransform {
+    transform(value: MediaType | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaTypeIconPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MediaTypeIconPipe, "mediaTypeIcon", true>;
+}
+
+declare class MediaTypePipe implements PipeTransform {
+    transform(value: MediaType | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MediaTypePipe, "mediaType", true>;
+}
+
+interface ImageFile {
+    file: File;
+    url: string;
+}
+declare enum DropClass {
+    Default = "drop-box",// Default color
+    Over = "drop-box hover"
+}
+declare class MediaDropDirective {
+    dropStart: EventEmitter<unknown>;
+    dropComplete: EventEmitter<Media>;
+    dropError: EventEmitter<HttpErrorResponse>;
+    private service;
+    constructor();
+    hostClass: DropClass;
+    dragOver(event: DragEvent): void;
+    dragLeave(event: DragEvent): void;
+    drop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MediaDropDirective, "[bdbMediaDrop]", never, {}, { "dropStart": "dropStart"; "dropComplete": "dropComplete"; "dropError": "dropError"; }, never, never, true, never>;
+}
+
+declare class BdbMediaUploadComponent {
+    class: string;
+    nativeInputFile?: ElementRef;
+    private mediaService;
+    accept: string;
+    uploadComplete: EventEmitter<Media>;
+    uploadError: EventEmitter<HttpErrorResponse>;
+    uploadStart: EventEmitter<void>;
+    private _pending;
+    get pending(): boolean;
+    onNativeInputFileSelect(event: Event): void;
+    selectFile(): void;
+    onDropStart(): void;
+    onDropError($event: HttpErrorResponse): void;
+    onDropComplete($event: Media): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbMediaUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbMediaUploadComponent, "bdb-media-upload", never, { "accept": { "alias": "accept"; "required": false; }; }, { "uploadComplete": "uploadComplete"; "uploadError": "uploadError"; "uploadStart": "uploadStart"; }, never, ["*"], true, never>;
+}
+
+declare enum TaskLogOutcome {
+    Noop = "Noop",
+    Success = "Success",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error"
+}
+declare const TaskLogOutcomeMap: Map<TaskLogOutcome, string>;
+
+declare class TaskLogOutcomePipe implements PipeTransform {
+    transform(value: TaskLogOutcome | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogOutcomePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogOutcomePipe, "taskLogOutcome", true>;
+}
+
+declare enum TaskLogStatus {
+    New = "New",
+    Running = "Running",
+    Waiting = "Waiting",
+    Completed = "Completed"
+}
+declare const TaskLogStatusMap: Map<TaskLogStatus, string>;
+
+declare class TaskLogStatusPipe implements PipeTransform {
+    transform(value: TaskLogStatus | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogStatusPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogStatusPipe, "taskLogStatus", true>;
+}
+
+declare enum TaskLogParameterType {
+    String = "String",
+    Int = "Int",
+    Decimal = "Decimal",
+    Bool = "Bool"
+}
+
+interface TaskLogParameter extends BdbEntity {
+    name: string;
+    type: TaskLogParameterType;
+    stringValue?: string;
+    intValue?: number;
+    decimalValue?: number;
+    boolValue?: boolean;
+}
+
+declare class TaskLogParameterValuePipe implements PipeTransform {
+    private locale;
+    constructor(locale: string);
+    transform(value: TaskLogParameter): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogParameterValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogParameterValuePipe, "taskLogParameterValue", true>;
+}
+
+interface UserRead extends BdbEntityRead {
+    email: string;
+    name: string;
+    roles: string[];
+}
+
+declare class UserTableComponent {
+    private matDialog;
+    private cb;
+    dataSource: BdbDataSource<UserRead>;
+    displayedColumns: string[];
+    rowClick: EventEmitter<UserRead>;
+    columns: BdbColumn<UserRead, unknown>[];
+    constructor(matDialog: MatDialog, cb: BdbColumnBuilder<UserRead>);
+    contextActions: BdbContextAction<UserRead>[];
+    onRowClick(user: UserRead): void;
+    onContextAction(event: {
+        action: BdbContextAction<UserRead>;
+        row: UserRead;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserTableComponent, "bdb-user-table[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "rowClick": "rowClick"; }, never, never, true, never>;
+}
+
+declare class BdbFlexChildDirective implements OnInit {
+    private element;
+    private renderer;
+    bdbFlexChild: string;
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbFlexChildDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbFlexChildDirective, "[bdbFlexChild]", never, { "bdbFlexChild": { "alias": "bdbFlexChild"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type FlexSpacing = {
+    align: string;
+    justify: string;
+};
+declare class BdbFlexDirective implements OnInit {
+    private element;
+    private renderer;
+    bdbFlex: string;
+    bdbFlexDirection: string;
+    bdbFlexGap: string;
+    bdbFlexSpacing: string;
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    setDirection(bdbFlexInput?: string): void;
+    getDirection(bdbFlexInput?: string): string;
+    validateDirection(direction: string): string;
+    setGap(bdbFlexInput?: string): void;
+    getGap(bdbFlexInput?: string): string;
+    validateGap(gap: string): string;
+    setSpacing(bdbFlexInput: Partial<FlexSpacing>): void;
+    getSpacing(bdbFlexInput: Partial<FlexSpacing>): FlexSpacing;
+    validateSpacing(spacing: FlexSpacing): FlexSpacing;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbFlexDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbFlexDirective, "[bdbFlex], [bdbFlexDirection], [bdbFlexGap], [bdbFlexSpacing]", never, { "bdbFlex": { "alias": "bdbFlex"; "required": false; }; "bdbFlexDirection": { "alias": "bdbFlexDirection"; "required": false; }; "bdbFlexGap": { "alias": "bdbFlexGap"; "required": false; }; "bdbFlexSpacing": { "alias": "bdbFlexSpacing"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbFormErrorDirective implements OnInit {
+    private element;
+    private renderer;
+    private controlContainer;
+    bdbFormError: string | AbstractControl;
+    control: AbstractControl;
+    constructor(element: ElementRef, renderer: Renderer2, controlContainer: ControlContainer);
+    ngOnInit(): void;
+    setError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbFormErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbFormErrorDirective, "[bdbFormError]", never, { "bdbFormError": { "alias": "bdbFormError"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbGridChildDirective implements OnInit {
+    private element;
+    private renderer;
+    bdbGridChild: string;
+    bdbGridRow: string;
+    bdbGridColumn: string;
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    splitAxes(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbGridChildDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbGridChildDirective, "[bdbGridChild], [bdbGridColumn], [bdbGridRow]", never, { "bdbGridChild": { "alias": "bdbGridChild"; "required": false; }; "bdbGridRow": { "alias": "bdbGridRow"; "required": false; }; "bdbGridColumn": { "alias": "bdbGridColumn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type BdbGridInput = {
+    gap?: string;
+    columns?: BdbGridAxisInput;
+    rows?: BdbGridAxisInput;
+};
+type BdbGridAxisInput = {
+    type: 'template' | 'auto';
+    input: string;
+};
+declare class BdbGridDirective implements OnInit {
+    private element;
+    private renderer;
+    bdbGrid: string;
+    bdbGridColumns: string;
+    bdbGridRows: string;
+    bdbGridGap: string;
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    parseBdbGridInput(): BdbGridInput;
+    setAxis(axis: 'columns' | 'rows', gridInput?: BdbGridAxisInput): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbGridDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbGridDirective, "[bdbGrid], [bdbGridColumns], [bdbGridRows], [bdbGridGap]", never, { "bdbGrid": { "alias": "bdbGrid"; "required": false; }; "bdbGridColumns": { "alias": "bdbGridColumns"; "required": false; }; "bdbGridRows": { "alias": "bdbGridRows"; "required": false; }; "bdbGridGap": { "alias": "bdbGridGap"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbAlertErrorResponseComponent implements OnChanges {
+    value: HttpErrorResponse | undefined | null;
+    dismissable: boolean;
+    dismiss: EventEmitter<void>;
+    loginFailed: boolean;
+    alertClass: string;
+    icon: string;
+    label: string;
+    message: string;
+    errorCode: string | undefined;
+    validationFailures(): string[] | null;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbAlertErrorResponseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbAlertErrorResponseComponent, "bdb-alert-error-response", never, { "value": { "alias": "value"; "required": false; }; "dismissable": { "alias": "dismissable"; "required": false; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+declare class BdbAlertComponent {
+    class: string;
+    label: string;
+    icon: string;
+    inline: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbAlertComponent, "bdb-alert", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class BdbBooleanDisplayComponent {
+    class: string;
+    value?: boolean | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbBooleanDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbBooleanDisplayComponent, "bdb-boolean-display", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BdbCollapseRowComponent {
+    collapsed: boolean;
+    canCollapse: boolean;
+    class: string;
+    get isCollapsed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbCollapseRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbCollapseRowComponent, "bdb-collapse-row", never, { "collapsed": { "alias": "collapsed"; "required": false; }; "canCollapse": { "alias": "canCollapse"; "required": false; }; }, {}, never, ["left", "right"], true, never>;
+}
+
+declare class BdbErrorResponseDialogComponent {
+    readonly data: {
+        title: string;
+        error: HttpErrorResponse;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbErrorResponseDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbErrorResponseDialogComponent, "bdb-error-response-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class BdbFieldComponent {
+    class: string;
+    label: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbFieldComponent, "bdb-field", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FileSizePipe implements PipeTransform {
+    transform(bytes: number | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", true>;
+}
+
+declare class PlainNumberPipe implements PipeTransform {
+    transform(value: number | undefined): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlainNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PlainNumberPipe, "bdbPlainNumber", true>;
+}
+
+interface AccountInfo {
+    email: string;
+    id: number;
+    roles: string[];
+    claims: Map<string, unknown>;
+}
+
+interface TokenResponse {
+    token: string;
+    refreshToken: string;
+    expiration: Date;
+}
+
+declare class AccountService extends BdbService {
+    constructor();
+    login(value: {
+        email: string;
+        password: string;
+    }): Observable<TokenResponse>;
+    exchangeRefreshToken(value: {
+        token: string;
+        refreshToken: string;
+    }): Observable<TokenResponse>;
+    forgotPassword(value: {
+        email: string;
+    }): Observable<boolean>;
+    resetPassword(value: {
+        email: string;
+        token: string;
+        password: string;
+    }): Observable<TokenResponse>;
+    validateResetPasswordToken(value: {
+        email: string;
+        token: string;
+    }): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}
+
+declare function getAuthorizationHeaderFromToken(token: string): string;
+declare function getTokenFromAuthorizationHeader(header: string): string;
+declare class AuthService {
+    private accountService;
+    token$: BehaviorSubject<string | null>;
+    account$: BehaviorSubject<AccountInfo | null>;
+    currentRefreshTokenRequest: Observable<string | null> | undefined;
+    matDialog: MatDialog;
+    router: Router;
+    readonly bdbOptions: _devopmaat_badaboom.BdbOptions;
+    constructor(accountService: AccountService);
+    login(value: {
+        email: string;
+        password: string;
+    }): Observable<TokenResponse>;
+    logout(): void;
+    refreshToken(expiredToken: string): Observable<string | null>;
+    resetPassword(value: {
+        email: string;
+        token: string;
+        password: string;
+    }): Observable<TokenResponse>;
+    forgotPassword(value: {
+        email: string;
+    }): Observable<boolean>;
+    validateResetPasswordToken(value: {
+        email: string;
+        token: string;
+    }): Observable<boolean>;
+    private processTokenResponse;
+    private getAccountInfoFromToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+interface ResetPasswordToken {
+    email: string;
+    token: string;
+}
+
+declare const tokenExpiredInterceptor: HttpInterceptorFn;
+
+declare const tokenInterceptor: HttpInterceptorFn;
+
+interface BdbEntityUpdate {
+    id: number;
+}
+
+declare abstract class BdbServiceCR<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityCreate> extends BdbServiceR<TEntity, TEntityRead> {
+    create(createModel: TEntityCreate): Observable<number>;
+}
+
+declare abstract class BdbServiceCRD<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityCreate> extends BdbServiceCR<TEntity, TEntityRead, TEntityCreate> {
+    delete(id: number): Observable<never>;
+}
+
+declare abstract class BdbServiceCRU<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityCreate, TEntityUpdate extends BdbEntityUpdate> extends BdbServiceCR<TEntity, TEntityRead, TEntityCreate> {
+    update(updateModel: TEntityUpdate): Observable<never>;
+}
+
+declare abstract class BdbServiceCRUD<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityCreate, TEntityUpdate extends BdbEntityUpdate> extends BdbServiceCRU<TEntity, TEntityRead, TEntityCreate, TEntityUpdate> {
+    delete(id: number): Observable<never>;
+}
+
+declare abstract class BdbServiceRD<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead> extends BdbServiceR<TEntity, TEntityRead> {
+    delete(id: number): Observable<never>;
+}
+
+declare abstract class BdbServiceRU<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityUpdate extends BdbEntityUpdate> extends BdbServiceR<TEntity, TEntityRead> {
+    update(updateModel: TEntityUpdate): Observable<TEntity>;
+}
+
+declare abstract class BdbServiceRUD<TEntity extends BdbEntity, TEntityRead extends BdbEntityRead, TEntityUpdate extends BdbEntityUpdate> extends BdbServiceRU<TEntity, TEntityRead, TEntityUpdate> {
+    delete(id: number): Observable<never>;
+}
+
+interface ExceptionLog extends BdbEntity {
+    code: string;
+    message: string;
+    description: string;
+    type: string;
+    created: Date;
+    createdBy: string;
+}
+
+declare class ExceptionLogService extends BdbServiceR<ExceptionLog, ExceptionLogRead> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExceptionLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExceptionLogService>;
+}
+
+declare class MediaService extends BdbServiceRD<Media, Media> {
+    constructor();
+    upload(file: File): Observable<Media>;
+    fromUrl(url: string): Observable<Media>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaService>;
+}
+
+interface Role extends BdbEntity {
+    name: string;
+}
+
+interface RoleRead extends BdbEntityRead {
+    name: string;
+    created: Date;
+    createdByEmail: string;
+    createdById: number;
+}
+
+declare class RoleService extends BdbServiceR<Role, RoleRead> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoleService>;
+}
+
+interface TaskLog extends BdbEntity {
+    taskType: string;
+    status: TaskLogStatus;
+    outcome: TaskLogOutcome;
+    start: Date;
+    completion: Date;
+    summary: string;
+    error?: string;
+    log: string;
+    parameters: TaskLogParameter[];
+}
+
+interface TaskLogParameterCreate {
+    name: string;
+    stringValue?: string;
+    intValue?: number;
+    decimalValue?: number;
+    boolValue?: boolean;
+}
+
+interface TaskLogCreate {
+    taskType: string;
+    parameters: TaskLogParameterCreate[];
+}
+
+interface TaskLogRead extends BdbEntityRead {
+    taskType: string;
+    status: TaskLogStatus;
+    outcome: TaskLogOutcome;
+    start: Date;
+    completion: Date;
+    summary: string;
+}
+
+declare class TaskLogService extends BdbServiceCR<TaskLog, TaskLogRead, TaskLogCreate> {
+    constructor();
+    start(id: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskLogService>;
+}
+
+interface TaskLogParameterRead extends BdbEntityRead {
+    name: string;
+    type: TaskLogParameterType;
+    stringValue?: string;
+    intValue?: number;
+    decimalValue?: number;
+    boolValue?: boolean;
+    isRequired: boolean;
+}
+
+declare class TaskLogParameterService extends BdbServiceR<TaskLogParameter, TaskLogParameterRead> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogParameterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskLogParameterService>;
+}
+
+interface TaskLogSchedule extends BdbEntity {
+    taskLogType: string;
+    description: string;
+    cronExpression: string;
+    isActive: boolean;
+}
+
+interface TaskLogScheduleCreate {
+    taskLogType: string;
+    cronExpression: string;
+    isActive: boolean;
+}
+
+interface TaskLogScheduleRead extends BdbEntityRead {
+    taskLogType: string;
+    description: string;
+    cronExpression: string;
+    isActive: boolean;
+}
+
+interface TaskLogScheduleUpdate extends BdbEntityUpdate {
+    cronExpression: string;
+    isActive: boolean;
+}
+
+declare class TaskLogScheduleService extends BdbServiceCRUD<TaskLogSchedule, TaskLogScheduleRead, TaskLogScheduleCreate, TaskLogScheduleUpdate> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogScheduleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskLogScheduleService>;
+}
+
+interface User extends BdbEntity {
+    email: string;
+    name: string;
+}
+
+interface UserCreate {
+    email: string;
+}
+
+interface UserUpdate extends BdbEntityUpdate {
+    email: string;
+}
+
+declare class UserService extends BdbServiceCRUD<User, UserRead, UserCreate, UserUpdate> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+
+interface UserRole extends BdbEntity {
+    user: User;
+    role: Role;
+}
+
+interface UserRoleCreate {
+    userId: number;
+    roleId: number;
+}
+
+interface UserRoleRead extends BdbEntityRead {
+    userEmail: string;
+    roleName: string;
+    userId: number;
+    roleId: number;
+}
+
+declare class UserRoleService extends BdbServiceCRD<UserRole, UserRoleRead, UserRoleCreate> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserRoleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserRoleService>;
+}
+
+declare class TaskLogSchedulerService extends BdbService {
+    constructor();
+    isRunning(): Observable<boolean>;
+    startScheduler(): Observable<void>;
+    stopScheduler(): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogSchedulerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskLogSchedulerService>;
+}
+
+interface TaskLogTypeParameter {
+    name: string;
+    description: string;
+    type: TaskLogParameterType;
+    required: boolean;
+    defaultStringValue: string;
+    defaultIntValue: number;
+    defaultDecimalValue: number;
+    defaultBoolValue: boolean;
+}
+
+interface TaskLogType {
+    identifier: string;
+    name: string;
+    description: string;
+    parameters?: TaskLogTypeParameter[];
+}
+
+declare class TaskLogTypeService extends BdbService {
+    TaskLogTypes: BehaviorSubject<TaskLogType[]>;
+    getAllObservable: Observable<TaskLogType[]> | null;
+    constructor();
+    load(): void;
+    private getAll;
+    get(identifier: string): Observable<TaskLogType | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogTypeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskLogTypeService>;
+}
+
+declare const loggedOutGuard: CanActivateFn;
+
+declare const resetPasswordResolver: ResolveFn<ResetPasswordToken>;
+
+declare function roleGuard(...roles: string[]): CanActivateFn;
+
+declare class AccessDeniedPageComponent implements OnInit, OnDestroy {
+    private authService;
+    private readonly _onDestroy;
+    loginRoutePath?: string;
+    logoutRoutePath?: string;
+    isLoggedIn: boolean;
+    constructor(bdbOptions: BdbOptions, authService: AuthService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccessDeniedPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccessDeniedPageComponent, "bdb-access-denied-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class AuthContainerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AuthContainerComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class ForgotPasswordPageComponent {
+    private authService;
+    loginRoutePath?: string;
+    emailCtrl: FormControl<string>;
+    isComplete: boolean;
+    isPending: boolean;
+    error?: HttpErrorResponse;
+    forgotPasswordForm: FormGroup<{
+        email: FormControl<string>;
+    }>;
+    constructor(authService: AuthService, bdbOptions: BdbOptions);
+    forgotPassword(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ForgotPasswordPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ForgotPasswordPageComponent, "bdb-forgot-password-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class InvalidTokenPageComponent {
+    loginRoutePath?: string;
+    constructor(bdbOptions: BdbOptions);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvalidTokenPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InvalidTokenPageComponent, "bdb-invalid-token-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoginPageComponent implements OnInit {
+    private router;
+    private authService;
+    private route;
+    forgotPasswordRoutePath?: string;
+    emailCtrl: FormControl<string>;
+    passwordCtrl: FormControl<string>;
+    error?: HttpErrorResponse;
+    postLoginUrl: string;
+    isPending: boolean;
+    loginForm: FormGroup<{
+        email: FormControl<string>;
+        password: FormControl<string>;
+    }>;
+    constructor(router: Router, authService: AuthService, route: ActivatedRoute, bdbOptions: BdbOptions);
+    ngOnInit(): void;
+    login(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginPageComponent, "bdb-login-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class LogoutPageComponent {
+    private router;
+    private authService;
+    private bdbOptions;
+    constructor(router: Router, authService: AuthService, bdbOptions: BdbOptions);
+    logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoutPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoutPageComponent, "bdb-logout-page", never, {}, {}, never, never, true, never>;
+}
+
+declare function equalValueValidator(otherControl: AbstractControl): ValidatorFn;
+declare class ResetPasswordPageComponent implements OnInit {
+    private authService;
+    private activatedRoute;
+    private router;
+    loginRoutePath?: string;
+    isPending: boolean;
+    error?: HttpErrorResponse;
+    passwordCtrl: FormControl<string>;
+    confirmPasswordCtrl: FormControl<string>;
+    resetPasswordForm: FormGroup<{
+        email: FormControl<string>;
+        token: FormControl<string>;
+        password: FormControl<string>;
+        confirmPassword: FormControl<string>;
+    }>;
+    resetPasswordToken?: ResetPasswordToken;
+    constructor(authService: AuthService, activatedRoute: ActivatedRoute, router: Router, bdbOptions: BdbOptions);
+    ngOnInit(): void;
+    resetPassword(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResetPasswordPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResetPasswordPageComponent, "bdb-reset-password-page", never, {}, {}, never, never, true, never>;
+}
+
+export { AccessDeniedPageComponent, AuthContainerComponent, AuthService, BDB_OPTIONS, BdbAlertComponent, BdbAlertErrorResponseComponent, BdbBooleanDisplayComponent, BdbCellDirective, BdbCollapseRowComponent, BdbColumnBuilder, BdbColumnType, BdbDataSource, BdbErrorResponseDialogComponent, BdbFieldComponent, BdbFlexChildDirective, BdbFlexDirective, BdbFormErrorDirective, BdbFullTableComponent, BdbGridChildDirective, BdbGridDirective, BdbMediaDisplayComponent, BdbMediaInputComponent, BdbMediaUploadComponent, BdbOptionsBuilder, BdbPaginatorComponent, BdbQueryInputComponent, BdbSearchComponent, BdbSearchWrapperBaseComponent, BdbService, BdbServiceCR, BdbServiceCRD, BdbServiceCRU, BdbServiceCRUD, BdbServiceR, BdbServiceRD, BdbServiceRU, BdbServiceRUD, BdbTableComponent, ExceptionLogService, ExceptionLogTableComponent, FileSizePipe, ForgotPasswordPageComponent, InvalidTokenPageComponent, LoginPageComponent, LogoutPageComponent, MediaDropDirective, MediaFullTableComponent, MediaService, MediaTableComponent, MediaType, MediaTypeIconPipe, MediaTypeMap, MediaTypePipe, PlainNumberPipe, ResetPasswordPageComponent, RoleService, TaskLogOutcome, TaskLogOutcomeMap, TaskLogOutcomePipe, TaskLogParameterService, TaskLogParameterType, TaskLogParameterValuePipe, TaskLogScheduleService, TaskLogSchedulerService, TaskLogService, TaskLogStatus, TaskLogStatusMap, TaskLogStatusPipe, TaskLogTypeService, UserRoleService, UserService, UserTableComponent, equalValueValidator, getAuthorizationHeaderFromToken, getTokenFromAuthorizationHeader, loggedOutGuard, provideBaDaBoom, resetPasswordResolver, roleGuard, tokenExpiredInterceptor, tokenInterceptor };
+export type { AccountInfo, BdbBooleanColumnOptions, BdbColumn, BdbColumnOptions, BdbContextAction, BdbCurrencyColumnOptions, BdbDateColumnOptions, BdbEntity, BdbEntityRead, BdbEntityUpdate, BdbEnumColumnOptions, BdbFilter, BdbM3Palette, BdbNumberColumnOptions, BdbOptions, BdbOptionsConfigure, BdbPalette, BdbPercentageColumnOptions, BdbRequest, BdbResponse, BdbStringColumnOptions, ExceptionLog, ExceptionLogRead, ImageFile, Media, MediaPreview, ResetPasswordToken, Role, RoleRead, TaskLog, TaskLogCreate, TaskLogParameter, TaskLogParameterCreate, TaskLogParameterRead, TaskLogRead, TaskLogSchedule, TaskLogScheduleCreate, TaskLogScheduleRead, TaskLogScheduleUpdate, TaskLogType, TaskLogTypeParameter, TokenResponse, User, UserCreate, UserRead, UserRole, UserRoleCreate, UserRoleRead, UserUpdate };