import * as _ngrx_store from '@ngrx/store';
import { Store, Action as Action$1, ActionReducerMap, ActionReducer, RuntimeChecks } from '@ngrx/store';
import * as i0 from '@angular/core';
import { AfterViewInit, OnChanges, OnDestroy, ElementRef, Renderer2, SimpleChanges, ClassProvider, ModuleWithProviders, InjectionToken, FactoryProvider, TemplateRef, EventEmitter, Type, ComponentFactoryResolver, ViewContainerRef, ChangeDetectorRef, PipeTransform, Provider, OnInit, ValueProvider, ApplicationRef, NgZone } from '@angular/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subscription, Observable } from 'rxjs';
import * as entity_store from 'entity-store';
import { Action, Selector, EntityTypeMap, EntityStateMap, ComposedEntityActions, KVS } from 'entity-store';
import * as dgp_ng_app from 'dgp-ng-app';
import * as i15 from '@angular/router';
import { Router, ActivatedRouteSnapshot, RouterStateSnapshot, ActivatedRoute } from '@angular/router';
import * as i2 from '@ngrx/effects';
import { EffectConfig } from '@ngrx/effects';
import * as i3 from '@angular/material/snack-bar';
import * as _angular_material_core from '@angular/material/core';
import { ThemePalette } from '@angular/material/core';
import * as i2$1 from '@angular/material/dialog';
import { MatDialogRef, MatDialogConfig, MatDialog } from '@angular/material/dialog';
import * as i3$1 from '@angular/material/button';
import * as i4 from '@angular/material/icon';
import * as i4$1 from '@angular/common';
import * as i2$2 from '@angular/material/toolbar';
import * as i12 from '@angular/cdk/platform';
import { Platform } from '@angular/cdk/platform';
import * as i5 from '@angular/material/list';
import * as i9 from '@angular/material/tooltip';
import { MatTooltip } from '@angular/material/tooltip';
import * as i21 from '@angular/material/menu';
import * as i1 from '@angular/platform-browser';
import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
import * as data_modeling from 'data-modeling';
import { Many, AttributeMetadata, Matrix, ModelMetadata } from 'data-modeling';
import * as i4$2 from '@angular/material/progress-bar';
import * as i6 from '@angular/material/sidenav';
import * as i2$3 from '@angular/cdk/layout';
import * as i6$1 from '@angular/forms';
import { ModelValidationResult } from 'data-modeling/src/lib/models';
import * as i8 from '@angular/material/slide-toggle';
import * as i7 from '@angular/material/form-field';
import * as i8$1 from '@angular/material/select';
import * as i9$1 from '@angular/material/input';
import * as i10 from '@angular/material/slider';
import * as i4$3 from '@angular/cdk/dialog';
import * as i9$2 from '@angular/material/divider';
import * as i5$1 from '@angular/material/progress-spinner';
import * as i7$1 from '@angular/cdk/overlay';
import { OverlayContainer } from '@angular/cdk/overlay';
import * as i3$2 from '@angular/material/card';
import * as i4$4 from '@angular/cdk/scrolling';
import * as i2$4 from '@angular/platform-browser/animations';

type FirstArg<T extends Function> = T extends (payload: infer U) => any ? U : never;

declare abstract class DgpContainer<TState = any> {
    protected readonly store: Store<TState>;
    constructor(store: Store<TState>);
    readonly dispatch: (x: Action) => void;
    readonly select: <TV>(x: Selector<TState, TV>) => rxjs.Observable<TV>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpContainer<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpContainer<any>, never, never, {}, {}, never, never, true, never>;
}

interface ActionContext {
    readonly key: string;
    readonly value: any;
    readonly type: string;
    readonly label: string;
}

interface ActionContextState {
    readonly selectedActionContext?: ActionContext;
}

declare class DgpActionContextDirective extends DgpContainer<ActionContextState> implements AfterViewInit, OnChanges, OnDestroy {
    protected readonly store: Store<ActionContextState>;
    private readonly elementRef;
    private readonly renderer;
    readonly tabindex = 0;
    readonly actionContextKey$: BehaviorSubject<string>;
    actionContextKey: string;
    actionContextValue: any;
    actionContextType: string;
    actionContextLabel: string;
    readonly subscription: Subscription;
    constructor(store: Store<ActionContextState>, elementRef: ElementRef, renderer: Renderer2);
    focus(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpActionContextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpActionContextDirective, "[dgpActionContext]", never, { "actionContextKey": { "alias": "actionContextKey"; "required": false; }; "actionContextValue": { "alias": "actionContextValue"; "required": false; }; "actionContextType": { "alias": "actionContextType"; "required": false; }; "actionContextLabel": { "alias": "actionContextLabel"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpActionContextModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpActionContextModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpActionContextModule, [typeof DgpActionContextDirective], [typeof _ngrx_store.StoreFeatureModule], [typeof DgpActionContextDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpActionContextModule>;
}

declare const deselectActionContext: _ngrx_store.ActionCreator<"[DgpActionContext] Deselect", (props: {
    readonly selectedActionContextKey?: string;
}) => {
    readonly selectedActionContextKey?: string;
} & _ngrx_store.Action<"[DgpActionContext] Deselect">>;

declare const selectActionContext: _ngrx_store.ActionCreator<"[DgpActionContext] Select", (props: {
    readonly actionContext: ActionContext;
}) => {
    readonly actionContext: ActionContext;
} & _ngrx_store.Action<"[DgpActionContext] Select">>;

type ActionContextStoreFeature = "DgpActionContext";

declare const actionContextStoreFeature: ActionContextStoreFeature;

declare const emptyActionContext: ActionContext;

declare const emptyActionContextState: ActionContextState;

declare const actionContextReducer: _ngrx_store.ActionReducer<ActionContextState, _ngrx_store.Action<string>>;

declare const actionContextFeatureSelector: _ngrx_store.MemoizedSelector<object, ActionContextState, _ngrx_store.DefaultProjectorFn<ActionContextState>>;

declare const isAnyActionContextSelected: _ngrx_store.MemoizedSelector<object, boolean, (s1: string) => boolean>;

declare function isActionContextSelected(actionContextKey: string): _ngrx_store.MemoizedSelector<object, boolean, (s1: string) => boolean>;

declare const getSelectedActionContext: _ngrx_store.MemoizedSelector<object, ActionContext, (s1: dgp_ng_app.ActionContextState) => ActionContext>;

declare const getSelectedActionContextKey: _ngrx_store.MemoizedSelector<object, string, (s1: ActionContext) => string>;

declare const getSelectedActionContextLabel: _ngrx_store.MemoizedSelector<object, string, (s1: ActionContext) => string>;

declare const getSelectedActionContextType: _ngrx_store.MemoizedSelector<object, string, (s1: ActionContext) => string>;

declare const getSelectedActionContextValue: _ngrx_store.MemoizedSelector<object, any, (s1: ActionContext) => any>;

declare const authenticateUser: _ngrx_store.ActionCreator<string, (props: {
    readonly user: any;
}) => {
    readonly user: any;
} & _ngrx_store.Action<string>>;

/**
 * Service for authenticating the user
 */
declare abstract class AuthenticationApiClient<TUser = any> {
    /**
     * Returns the user via a means of
     * authentication
     */
    abstract authenticate$(): Promise<TUser>;
}
interface AuthenticationApiClientProvider extends ClassProvider {
    provide: typeof AuthenticationApiClient;
}

/**
 * Object describing the outcome
 * of an authentication attempt.
 *
 * Depending on the value of success
 * either the user or the errorMessage
 * attribute is set.
 */
interface AuthenticationState {
    readonly success: boolean;
    readonly error?: any;
    readonly user?: any;
    readonly initialUrl: string;
    readonly isInitialized?: boolean;
}
type PostAuthenticationTask<TUser> = (user: TUser) => Promise<void>;
declare const authenticationStoreFeature = "Authentication";

declare class AuthenticationGuard {
    private readonly store;
    private readonly router;
    constructor(store: Store<AuthenticationState>, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationGuard>;
}

declare const getIsAuthenticatedSelector: _ngrx_store.MemoizedSelector<object, boolean, (s1: AuthenticationState) => boolean>;
declare const isAuthenticated: _ngrx_store.MemoizedSelector<object, boolean, (s1: AuthenticationState) => boolean>;
declare const getAuthenticatedUserSelector: _ngrx_store.MemoizedSelector<object, any, (s1: AuthenticationState) => any>;
declare const getAuthenticatedUser: _ngrx_store.MemoizedSelector<object, any, (s1: AuthenticationState) => any>;
declare const isInitialized: _ngrx_store.MemoizedSelector<object, boolean, (s1: AuthenticationState) => boolean>;

declare abstract class AuthenticationService<TUser = any> {
    abstract authenticate$(): Promise<void>;
    abstract registerPostAuthenticationTask(task: PostAuthenticationTask<TUser>): void;
}
declare class AuthenticationServiceImpl<TUser> implements AuthenticationService<TUser> {
    private readonly store;
    private readonly authenticationApiClient;
    private readonly postAuthenticationTasks;
    constructor(store: Store<AuthenticationState>, authenticationApiClient: AuthenticationApiClient);
    authenticate$(): Promise<void>;
    registerPostAuthenticationTask(task: PostAuthenticationTask<TUser>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationServiceImpl<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationServiceImpl<any>>;
}
declare const authenticationServiceProvider: ClassProvider;

declare const initialAuthenticationState: AuthenticationState;
declare const authenticationReducer: _ngrx_store.ActionReducer<AuthenticationState, _ngrx_store.Action<string>>;

/**
 * Service that runs tasks once the user is authenticated
 * but before the application actually starts.
 *
 * Use for downloading basic data or load user settings.
 */
declare abstract class InitializationService<TUser = any> {
    /**
     * Runs tasks on app start
     */
    abstract runPostAuthenticationTask$(user: TUser): Promise<void>;
}
interface InitializationServiceProvider extends ClassProvider {
    provide: typeof InitializationService;
}

interface AuthenticationModuleSettings {
    readonly authenticationApiClientProvider: AuthenticationApiClientProvider;
    readonly initializationServiceProvider: InitializationServiceProvider;
}
declare class DgpAuthenticationModule {
    static forRoot(settings: AuthenticationModuleSettings): ModuleWithProviders<DgpAuthenticationModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpAuthenticationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpAuthenticationModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpAuthenticationModule>;
}

interface BroadcastRoleDisplayConfig {
    readonly leaderBrowserTabTitleSuffix: string;
    readonly peonBrowserTabTitleSuffix: string;
}

/**
 * @deprecated use BroadcastInitialEntityStoreContentRule instead
 */
type SendInitialStateSignature<TEntityTypeMap extends EntityTypeMap, TStoreFeature = string> = (state: EntityStateMap<TEntityTypeMap>) => ComposedEntityActions<TEntityTypeMap, TStoreFeature>;

type BroadcastInitialStateActionRule<TAppState> = (state: TAppState) => Action$1;

type BroadcastInitialEntityStoreContentRule<TEntityTypeMap extends EntityTypeMap, TStoreFeature = string> = SendInitialStateSignature<TEntityTypeMap, TStoreFeature>;

type BroadcastInitialStateRule<TEntityTypeMap extends EntityTypeMap, TStoreFeature = string> = BroadcastInitialStateActionRule<TEntityTypeMap> | BroadcastInitialEntityStoreContentRule<TEntityTypeMap, TStoreFeature>;

type BroadCastInitialStateRules<TEntityTypeMap extends EntityTypeMap, TStoreFeature = string> = ReadonlyArray<BroadcastInitialStateRule<TEntityTypeMap, TStoreFeature>>;

interface BroadcastConfig<TEntityTypeMap extends EntityTypeMap = {
    [key: string]: any;
}, TStoreFeature = string> {
    /**
     * The interval at which this participant sends
     * heartbeats
     *
     * default: 1000 ms
     */
    readonly heartbeartBroadcastInterval: number;
    /**
     * The interval at which this participant buffers
     * incoming heartbeats before checking the current
     * roles
     *
     * default: 3000 ms
     */
    readonly incomingHeartbeatBufferInterval: number;
    /**
     * Id of the channel the broadcasts this participant's heartbeats
     */
    readonly heartbeatBroadcastChannelId: string;
    /**
     * Id of the channel the broadcasts this participant's actions
     */
    readonly actionBroadcastChannelId: string;
    /**
     * Action types to prefix
     */
    readonly actionTypesToPrefixWithPeon: ReadonlyArray<string>;
    /**
     * Indicates whether and how browser-tab titles are used
     * to indicate status
     */
    readonly updateBrowserTabTitleConfig?: BroadcastRoleDisplayConfig;
    readonly sendInitialState?: SendInitialStateSignature<TEntityTypeMap, TStoreFeature> | BroadCastInitialStateRules<TEntityTypeMap, TStoreFeature>;
    readonly syncSelection?: boolean;
    /**
     * Indicates whether this window can be a leader
     * or is intended to support the main application.
     *
     * This can be used for scenarios where there is
     * a main application and sub-apps that have no process
     * control of their own.
     */
    readonly canBeLeader: boolean;
}

interface BroadcastParticipant {
    /**
     * Unique identifier of the window or tab that sends this
     * request
     */
    readonly participantId: string;
    readonly participantCreationDate: Date;
    readonly canBeLeader: boolean;
}

interface DataBroadcastChannel extends BroadcastParticipant {
    readonly dataId?: any;
}

interface BroadcastAction extends DataBroadcastChannel, Action$1 {
}

interface BroadcastChannelLike {
    postMessage(message: any): void;
    addEventListener(type: any, listener: any, options?: boolean | AddEventListenerOptions): void;
}

interface BroadcastHeartbeat extends DataBroadcastChannel {
}

declare enum BroadcastRole {
    None = 0,
    Leader = 1,
    Peon = 2
}

interface MessageEventLike {
    readonly data: any;
}

declare class SetOwnBroadcastRoleAction implements Action$1 {
    readonly payload: BroadcastRole;
    readonly type = "[BroadcastChannel] SetOwnRole";
    constructor(payload: BroadcastRole);
}
declare class SetBroadcastChannelDataIdAction implements Action$1 {
    readonly payload: any;
    readonly type = "[BroadcastChannel] SetSelectedDataId";
    constructor(payload: any);
}
declare const setBroadcastChannelDataId: _ngrx_store.ActionCreator<"[BroadcastChannel] SetSelectedDataId", (props: {
    readonly payload: any;
}) => {
    readonly payload: any;
} & Action$1<"[BroadcastChannel] SetSelectedDataId">>;

declare const broadcastStoreFeature = "Broadcast";
declare const broadcastStoreFeatureSelector: _ngrx_store.MemoizedSelector<object, BroadcastState, _ngrx_store.DefaultProjectorFn<BroadcastState>>;
interface BroadcastState {
    readonly ownRole: BroadcastRole;
}
declare const broadcastReducer: _ngrx_store.ActionReducer<BroadcastState, _ngrx_store.Action<string>>;
declare const getOwnBroadcastRoleSelector: _ngrx_store.MemoizedSelector<object, BroadcastRole, (s1: BroadcastState) => BroadcastRole>;

declare class NoPeonGuard {
    private readonly store;
    constructor(store: Store<BroadcastState>);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoPeonGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NoPeonGuard>;
}

declare function createGuid(): string;

declare const BROADCAST_CONFIG: InjectionToken<Readonly<BroadcastConfig<{
    [key: string]: any;
}, string>>>;

declare const defaultBroadcastRoleDisplayConfig: BroadcastRoleDisplayConfig;

declare const defaultBroadcastConfig: BroadcastConfig;

declare const heartbeatBroadcastChannelId = "HeartbeatBroadcastChannel";

declare const actionBroadcastChannelId = "ActionBroadcastChannel";

declare const BROADCAST_REDUCER: InjectionToken<ActionReducerMap<BroadcastState, _ngrx_store.Action<string>>>;
declare const broadcastReducerProvider: FactoryProvider;
declare class DgpBroadcastStoreModule {
    static forRoot<TEntityTypeMap extends EntityTypeMap = {
        [key: string]: any;
    }, TStoreFeature = string>(config?: BroadcastConfig<TEntityTypeMap, TStoreFeature>): ModuleWithProviders<DgpBroadcastStoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpBroadcastStoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpBroadcastStoreModule, never, [typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule, typeof i3.MatSnackBarModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpBroadcastStoreModule>;
}

interface RemovalDialogButtonConfig {
    readonly label: string;
    readonly matIconName: string;
    readonly color?: ThemePalette;
    readonly returnValue: boolean | null;
}
declare const cancelButtonConfig: RemovalDialogButtonConfig;
declare const confirmButtonConfig: RemovalDialogButtonConfig;
declare class DgpConfirmDialogComponent {
    title: string;
    confirmButtonConfig: RemovalDialogButtonConfig;
    cancelButtonConfig: RemovalDialogButtonConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpConfirmDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpConfirmDialogComponent, "dgp-confirm-dialog", never, { "title": { "alias": "title"; "required": false; }; "confirmButtonConfig": { "alias": "confirmButtonConfig"; "required": false; }; "cancelButtonConfig": { "alias": "cancelButtonConfig"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class DgpConfirmDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpConfirmDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpConfirmDialogModule, [typeof DgpConfirmDialogComponent], [typeof i2$1.MatDialogModule, typeof i3$1.MatButtonModule, typeof i4.MatIconModule], [typeof DgpConfirmDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpConfirmDialogModule>;
}

declare class DgpDialogMenuComponent {
    readonly template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDialogMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpDialogMenuComponent, "dgp-dialog-menu", never, {}, {}, never, never, false, never>;
}

declare class DgpDialogMenuService {
    private currentDialogMenu;
    cacheCurrentDialogMenu(editor: MatDialogRef<any>): void;
    closeCurrentDialogMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDialogMenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DgpDialogMenuService>;
}

declare class DgpDialogMenuTriggerDirective {
    private readonly triggerElRef;
    private readonly matDialog;
    private readonly service;
    dialogConfig: MatDialogConfig;
    readonly dialogMenuOpened: EventEmitter<any>;
    readonly dialogMenuClosed: EventEmitter<any>;
    disabled: boolean;
    templateRef: TemplateRef<any>;
    private dialogRef;
    constructor(triggerElRef: ElementRef, matDialog: MatDialog, service: DgpDialogMenuService);
    openDialogMenu(): Promise<void>;
    closeMenuDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDialogMenuTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpDialogMenuTriggerDirective, "[dgpDialogMenuTrigger]", never, { "dialogConfig": { "alias": "dialogConfig"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "templateRef": { "alias": "templateRef"; "required": false; }; }, { "dialogMenuOpened": "dialogMenuOpened"; "dialogMenuClosed": "dialogMenuClosed"; }, never, never, false, never>;
}

declare class DgpDialogMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDialogMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpDialogMenuModule, [typeof DgpDialogMenuComponent, typeof DgpDialogMenuTriggerDirective], [typeof i4$1.CommonModule, typeof i2$1.MatDialogModule], [typeof DgpDialogMenuComponent, typeof DgpDialogMenuTriggerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpDialogMenuModule>;
}

type ExpansionTogglePosition = "start" | "end";

interface Details {
    readonly summary: string;
    readonly expanded: boolean;
    readonly expandable: boolean;
    readonly togglePosition: ExpansionTogglePosition;
}

declare class DgpDetailsComponent implements AfterViewInit, Details {
    readonly expanded$: rxjs.Observable<boolean>;
    detailsElementRef: ElementRef<HTMLDetailsElement>;
    summary: string;
    expanded: boolean;
    expandable: boolean;
    togglePosition: ExpansionTogglePosition;
    readonly expandedChange: EventEmitter<boolean>;
    ngAfterViewInit(): void;
    updateExpanded(expanded: boolean): void;
    onToggle($event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpDetailsComponent, "dgp-details", never, { "summary": { "alias": "summary"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["[summary]", "*"], false, never>;
}

declare abstract class DgpDisabledBase {
    disabled: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDisabledBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpDisabledBase, never, never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class DgpViewComponentBase<TModel> extends DgpDisabledBase {
    protected modelValue: TModel;
    readonly model$: rxjs.Observable<TModel>;
    constructor();
    model: TModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpViewComponentBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpViewComponentBase<any>, never, never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Base class for classes for manipulating a model
 */
declare abstract class DgpModelEditorComponentBase<TModel> extends DgpViewComponentBase<TModel> {
    readonly modelChange: EventEmitter<TModel>;
    setModel(value: TModel): void;
    updateModel(value: Partial<TModel> | TModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpModelEditorComponentBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpModelEditorComponentBase<any>, never, never, {}, { "modelChange": "modelChange"; }, never, never, true, never>;
}

declare class DgpExpansionToggleComponent extends DgpModelEditorComponentBase<boolean> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpExpansionToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpExpansionToggleComponent, "dgp-expansion-toggle", never, {}, {}, never, never, false, never>;
}

declare class DgpExpansionToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpExpansionToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpExpansionToggleModule, [typeof DgpExpansionToggleComponent], [typeof i3$1.MatButtonModule, typeof i4.MatIconModule, typeof i4$1.CommonModule], [typeof DgpExpansionToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpExpansionToggleModule>;
}

declare class SpacerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpacerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpacerComponent, "dgp-spacer", never, {}, {}, never, never, false, never>;
}

declare class DgpSpacerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpSpacerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpSpacerModule, [typeof SpacerComponent], never, [typeof SpacerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpSpacerModule>;
}

declare class DgpDetailsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDetailsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpDetailsModule, [typeof DgpDetailsComponent], [typeof DgpExpansionToggleModule, typeof DgpSpacerModule, typeof i4.MatIconModule, typeof i4$1.NgIf], [typeof DgpDetailsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpDetailsModule>;
}

declare class DgpPageHeaderContextActionsComponent extends DgpContainer<ActionContextState> {
    readonly isAnyActionContextSelected$: rxjs.Observable<boolean>;
    readonly currentActionContextLabel$: rxjs.Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpPageHeaderContextActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpPageHeaderContextActionsComponent, "dgp-page-header-context-actions", never, {}, {}, never, ["*"], false, never>;
}

declare class DgpPageHeaderContextActionsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpPageHeaderContextActionsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpPageHeaderContextActionsModule, [typeof DgpPageHeaderContextActionsComponent], [typeof i2$2.MatToolbarModule, typeof i4$1.CommonModule], [typeof DgpPageHeaderContextActionsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpPageHeaderContextActionsModule>;
}

declare class EmptyStateComponent {
    matIconName: string;
    title: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateComponent, "dgp-empty-state", never, { "matIconName": { "alias": "matIconName"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class EmptyStateContentComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateContentComponent, "dgp-empty-state-content", never, {}, {}, never, ["*"], false, never>;
}

declare class EmptyStateIconComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateIconComponent, "dgp-empty-state-icon", never, {}, {}, never, ["*"], false, never>;
}

declare class EmptyStateTitleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateTitleComponent, "dgp-empty-state-title", never, {}, {}, never, ["*"], false, never>;
}

declare class DgpEmptyStateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpEmptyStateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpEmptyStateModule, [typeof EmptyStateComponent, typeof EmptyStateContentComponent, typeof EmptyStateIconComponent, typeof EmptyStateTitleComponent], [typeof i4$1.CommonModule, typeof i4.MatIconModule], [typeof EmptyStateComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpEmptyStateModule>;
}

interface FileItemId {
    readonly fileItemId: string;
}
interface FileItem extends FileItemId {
    readonly fileName: string;
    readonly extension: string;
    /**
     * File size in bytes
     */
    readonly size: number;
    readonly url: string;
    readonly creationDate: Date;
    /**
     * Indicates whether this item has
     * already been saved.
     *
     * When a new item is uploaded, this
     * flag is true, so the developer
     * has a means of knowing which items to
     * persist.
     */
    readonly isSaved?: boolean;
}
interface Directory {
    readonly directoryId: string;
    readonly label: string;
    readonly fileItemIds: ReadonlyArray<string>;
}
interface FileTypeViewerMap {
    [key: string]: Type<any>;
}
declare const FILE_VIEWER_CONFIG: InjectionToken<FileViewerConfig>;
interface FileViewerConfig {
    readonly fileTypeViewerMap: FileTypeViewerMap;
}
interface FileItemListModel {
    readonly fileItemKVS: KVS<FileItem>;
    readonly directories: ReadonlyArray<Directory>;
}

declare function getFileItemSizeLabel(size: number): string;

declare abstract class FileViewerComponentBase {
    fileItem: FileItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileViewerComponentBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FileViewerComponentBase, never, never, { "fileItem": { "alias": "fileItem"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FallbackFileViewerComponent extends FileViewerComponentBase implements AfterViewInit {
    private readonly platform;
    isTridentOrEdge: boolean;
    constructor(platform: Platform);
    ngAfterViewInit(): void;
    downloadFileInTridentOrEdge(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FallbackFileViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FallbackFileViewerComponent, "dgp-fallback-file-viewer", never, {}, {}, never, never, false, never>;
}

declare enum DrawerMode {
    Side = "side",
    Over = "over"
}
interface IsDrawerOpenInfo {
    readonly isDrawerOpen: boolean;
}
interface IsDrawerOpenInfoProperty extends IsDrawerOpenInfo {
    readonly isDrawerOpenChange: Observable<boolean>;
}
interface DrawerLayout extends IsDrawerOpenInfo {
    readonly drawerMode: DrawerMode;
}
declare enum DrawerLayoutMenuTogglePosition {
    /**
     * Places the toggle to the right of the menu and centers it vertically.
     */
    RightToMenuAndVerticallyCentered = "rightToMenuAndVerticallyCentered",
    /**
     * Removes the default toggle so the user can place the component elsewhere
     */
    Custom = "custom"
}

type OpenFileManagerShortKeyFilter = (x: KeyboardEvent) => boolean;
interface FileUploadEditingCapabilities {
    readonly canAddFiles: boolean;
    readonly canRemoveFiles: boolean;
}
interface FileUploadConfig {
    readonly fileManagerMatDialogConfig: MatDialogConfig;
    readonly maximizedClass: string;
    readonly openFileManagerShortKeyFilter: OpenFileManagerShortKeyFilter;
    readonly editingCapabilities: FileUploadEditingCapabilities;
    readonly canOpenFileDrawer: boolean;
}
declare function openFileManagerShortKeyFilter(x: KeyboardEvent): boolean;
declare const defaultFileUploadConfig: FileUploadConfig;
declare const FILE_UPLOAD_CONFIG: InjectionToken<FileUploadConfig>;
interface FileUploadEntities {
    readonly directory: Directory;
    readonly fileItem: FileItem;
}
interface FileUploadQueryParams {
    readonly fileItemId?: string;
}
interface FileUploadState extends EntityStateMap<FileUploadEntities> {
    readonly isFileManagerOpen: boolean;
    readonly isDropTargetVisible: boolean;
    readonly initialConfig: FileUploadConfig;
    readonly fileDrawerLayout: DrawerLayout;
}
type FileUploadStoreFeature = "FileUpload";
declare const fileUploadStoreFeature: FileUploadStoreFeature;

declare class FileItemListComponent extends DgpContainer<FileUploadState> {
    disabled: boolean;
    model: FileItemListModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileItemListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileItemListComponent, "dgp-file-item-list", never, { "disabled": { "alias": "disabled"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FileViewerComponent extends FileViewerComponentBase implements OnChanges {
    private readonly config;
    isKnownFileType: boolean;
    constructor(config: FileViewerConfig);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileViewerComponent, "dgp-file-viewer", never, {}, {}, never, never, false, never>;
}

declare class DynamicFileViewerComponent extends FileViewerComponentBase implements OnChanges {
    private readonly componentFactoryResolver;
    private readonly viewContainerRef;
    private readonly config;
    constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, config: FileViewerConfig);
    ngOnChanges(changes: SimpleChanges): void;
    private loadComponent;
    private clear;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFileViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFileViewerComponent, "dgp-dynamic-file-viewer", never, {}, {}, never, never, false, never>;
}

declare class JpgViewerComponent extends FileViewerComponentBase {
    private readonly platform;
    readonly isTrident: boolean;
    constructor(platform: Platform);
    static ɵfac: i0.ɵɵFactoryDeclaration<JpgViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JpgViewerComponent, "dgp-jpg-viewer", never, {}, {}, never, never, false, never>;
}

declare class PdfViewerComponent extends FileViewerComponentBase implements OnChanges {
    readonly platform: Platform;
    private readonly cd;
    edgeHTML: any;
    constructor(platform: Platform, cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PdfViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PdfViewerComponent, "dgp-pdf-viewer", never, {}, {}, never, never, false, never>;
}

declare class PngViewerComponent extends FileViewerComponentBase {
    private readonly platform;
    readonly isTrident: boolean;
    constructor(platform: Platform);
    static ɵfac: i0.ɵɵFactoryDeclaration<PngViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PngViewerComponent, "dgp-png-viewer", never, {}, {}, never, never, false, never>;
}

declare class SvgViewerComponent extends FileViewerComponentBase {
    private readonly platform;
    readonly isTrident: boolean;
    constructor(platform: Platform);
    static ɵfac: i0.ɵɵFactoryDeclaration<SvgViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SvgViewerComponent, "dgp-svg-viewer", never, {}, {}, never, never, false, never>;
}

declare class RemoveCurrentFileItemActionComponent extends DgpContainer<FileUploadState> {
    readonly canRemoveCurrentFileItem$: rxjs.Observable<boolean>;
    removeCurrentFileItem(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveCurrentFileItemActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RemoveCurrentFileItemActionComponent, "dgp-remove-current-file-item-action", never, {}, {}, never, never, false, never>;
}

declare class DownloadCurrentFileItemComponent extends DgpContainer<FileUploadState> {
    downloadCurrentFileItem(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadCurrentFileItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadCurrentFileItemComponent, "dgp-download-current-file-item", never, {}, {}, never, never, false, never>;
}

declare abstract class DgpView<TModel> extends DgpViewComponentBase<TModel> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpView<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpView<any>, never, never, {}, {}, never, never, true, never>;
}

declare class FileItemListItemComponent extends DgpView<FileItem> {
    getFileItemSize(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileItemListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileItemListItemComponent, "dgp-file-item-list-item", never, {}, {}, never, never, false, never>;
}

declare class SafePipe implements PipeTransform {
    protected readonly sanitizer: DomSanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
}

declare class SafePipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SafePipeModule, [typeof SafePipe], never, [typeof SafePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SafePipeModule>;
}

interface InspectorConfig {
    readonly responsive: boolean;
    readonly fieldLabelThemeColor: ThemePalette;
    readonly showFieldIcons: boolean;
    readonly maxContentWidth: string;
    readonly showFieldDescriptions: boolean | "onHover";
}

interface ThemeSwitcherState {
    readonly useDarkMode: boolean;
    readonly useCompactTheme: boolean;
    /**
     * Components
     */
    readonly inspector?: InspectorConfig;
}
interface ThemeSwitcherConfig {
    readonly darkThemeClassName: string;
    readonly isDarkModeActiveLocalStorageKey?: string;
    readonly compactThemeClassName: string;
    readonly components: Many<string>;
}
declare const themeSwitcherStoreFeature = "ThemeSwitcher";

declare class InspectorService {
    private readonly payload;
    private readonly themeSwitcherConfig;
    private readonly store;
    readonly config$: BehaviorSubject<InspectorConfig>;
    readonly fieldLabelThemeColor$: rxjs.Observable<_angular_material_core.ThemePalette>;
    readonly maxContentWidth$: rxjs.Observable<string>;
    readonly responsive$: rxjs.Observable<boolean>;
    readonly showFieldDescriptions$: rxjs.Observable<boolean | "onHover">;
    readonly showFieldIcons$: rxjs.Observable<boolean>;
    constructor(payload: InspectorConfig, themeSwitcherConfig: ThemeSwitcherConfig, store: Store<ThemeSwitcherState>);
    updateConfig(payload: Partial<InspectorConfig>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InspectorService, [{ optional: true; }, { optional: true; }, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InspectorService>;
}

declare class InspectorComponent implements InspectorConfig {
    private readonly service;
    fieldLabelThemeColor: ThemePalette;
    maxContentWidth: string;
    showFieldDescriptions: boolean | "onHover";
    showFieldIcons: boolean;
    responsive: boolean;
    private readonly fieldLabelThemeColor$;
    private readonly maxContentWidth$;
    private readonly responsive$;
    private readonly showFieldDescriptions$;
    private readonly showFieldIcons$;
    constructor(service: InspectorService);
    static ɵfac: i0.ɵɵFactoryDeclaration<InspectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InspectorComponent, "dgp-inspector", never, { "fieldLabelThemeColor": { "alias": "fieldLabelThemeColor"; "required": false; }; "maxContentWidth": { "alias": "maxContentWidth"; "required": false; }; "showFieldDescriptions": { "alias": "showFieldDescriptions"; "required": false; }; "showFieldIcons": { "alias": "showFieldIcons"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class InspectorItemComponent {
    private readonly service;
    maxContentWidth: string;
    metadata: AttributeMetadata<any>;
    readonly metadata$: rxjs.Observable<AttributeMetadata<any, number>>;
    label: string;
    description: string;
    readonly description$: rxjs.Observable<string>;
    readonly metadataDescription$: rxjs.Observable<string>;
    matIconName: string;
    required: boolean;
    responsive: boolean;
    labelThemeColor: ThemePalette;
    showIcon: boolean;
    showDescription: boolean | "onHover";
    readonly responsive$: rxjs.Observable<boolean>;
    readonly showDescription$: rxjs.Observable<boolean | "onHover">;
    readonly showIcon$: rxjs.Observable<boolean>;
    readonly hasHoverDescription$: rxjs.Observable<boolean>;
    readonly hasPermanentDescription$: rxjs.Observable<boolean>;
    readonly maxContentWidth$: rxjs.Observable<string>;
    readonly labelThemeColor$: rxjs.Observable<ThemePalette>;
    constructor(service: InspectorService);
    static ɵfac: i0.ɵɵFactoryDeclaration<InspectorItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InspectorItemComponent, "dgp-inspector-item", never, { "maxContentWidth": { "alias": "maxContentWidth"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "matIconName": { "alias": "matIconName"; "required": false; }; "required": { "alias": "required"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "labelThemeColor": { "alias": "labelThemeColor"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "showDescription": { "alias": "showDescription"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class InspectorSectionComponent {
    matIconName: string;
    label: string;
    expanded: boolean;
    expandable: boolean;
    togglePosition: ExpansionTogglePosition;
    metadata: AttributeMetadata<any>;
    readonly expandedChange: EventEmitter<boolean>;
    updateExpanded(expanded: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InspectorSectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InspectorSectionComponent, "dgp-inspector-section", never, { "matIconName": { "alias": "matIconName"; "required": false; }; "label": { "alias": "label"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["[actions]", "*"], false, never>;
}

declare class DgpNegatePipe implements PipeTransform {
    transform(value: boolean | any, ...args: any[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpNegatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DgpNegatePipe, "negate", false>;
}

declare class DgpNegatePipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpNegatePipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpNegatePipeModule, [typeof DgpNegatePipe], never, [typeof DgpNegatePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpNegatePipeModule>;
}

declare class DgpInspectorModule {
    static forRoot(payload: Partial<InspectorConfig>): ModuleWithProviders<DgpInspectorModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInspectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpInspectorModule, [typeof InspectorComponent, typeof InspectorItemComponent, typeof InspectorSectionComponent], [typeof i4$1.CommonModule, typeof i5.MatListModule, typeof DgpSpacerModule, typeof i4.MatIconModule, typeof DgpExpansionToggleModule, typeof i9.MatTooltipModule, typeof DgpNegatePipeModule, typeof DgpDetailsModule], [typeof InspectorComponent, typeof InspectorItemComponent, typeof InspectorSectionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpInspectorModule>;
}

type TriggerEvent = "click";
interface ActionShortcutConfig {
    readonly requireAlt: boolean;
    readonly requireCtrl: boolean;
    readonly requireShift: boolean;
    readonly triggerEvent?: TriggerEvent;
}
interface ActionShortcut extends ActionShortcutConfig {
    readonly shortcutKey: string;
}
declare const defaultActionShortcutConfig: ActionShortcutConfig;
interface ShortcutConfig {
    readonly action: ActionShortcutConfig;
}
declare const defaultShortcutConfig: ShortcutConfig;
declare const SHORTCUT_CONFIG: InjectionToken<ShortcutConfig>;
declare function provideShortcutConfig(payload?: ShortcutConfig): Provider;

declare class DgpActionShortcutDirective extends DgpDisabledBase implements OnInit, OnDestroy, ActionShortcut {
    private readonly elRef;
    private readonly config;
    private readonly matTooltip;
    /**
     * The regular disabled input can be used as proxy
     * for disabled inputs
     *
     * Only disabling the shortcut is  available via
     * this input
     */
    isShortcutDisabled: boolean;
    shortcutKey: string;
    requireAlt: boolean;
    requireCtrl: boolean;
    requireShift: boolean;
    triggerEvent: TriggerEvent;
    readonly shortcutTriggered: EventEmitter<any>;
    constructor(elRef: ElementRef<HTMLElement>, config: ShortcutConfig, matTooltip: MatTooltip);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private onKeyDown;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpActionShortcutDirective, [null, { optional: true; }, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpActionShortcutDirective, "[dgpActionShortcut]", never, { "isShortcutDisabled": { "alias": "isShortcutDisabled"; "required": false; }; "shortcutKey": { "alias": "shortcutKey"; "required": false; }; "requireAlt": { "alias": "requireAlt"; "required": false; }; "requireCtrl": { "alias": "requireCtrl"; "required": false; }; "requireShift": { "alias": "requireShift"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; }, { "shortcutTriggered": "shortcutTriggered"; }, never, never, false, never>;
}

declare class DgpShortcutModule {
    static forRoot(config?: ShortcutConfig): ModuleWithProviders<DgpShortcutModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpShortcutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpShortcutModule, [typeof DgpActionShortcutDirective], never, [typeof DgpActionShortcutDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpShortcutModule>;
}

declare const defaultFileTypeViewerMap: FileTypeViewerMap;
declare const defaultFileViewerConfig: FileViewerConfig;
declare class DgpFileViewerModule {
    static forRoot(config?: FileViewerConfig): ModuleWithProviders<DgpFileViewerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpFileViewerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpFileViewerModule, [typeof PdfViewerComponent, typeof JpgViewerComponent, typeof PngViewerComponent, typeof SvgViewerComponent, typeof FileViewerComponent, typeof FallbackFileViewerComponent, typeof FileItemListComponent, typeof DynamicFileViewerComponent, typeof RemoveCurrentFileItemActionComponent, typeof DownloadCurrentFileItemComponent, typeof FileItemListItemComponent], [typeof i12.PlatformModule, typeof DgpEmptyStateModule, typeof i5.MatListModule, typeof i15.RouterModule, typeof i4$1.CommonModule, typeof i9.MatTooltipModule, typeof i4.MatIconModule, typeof DgpSpacerModule, typeof i3$1.MatButtonModule, typeof i21.MatMenuModule, typeof SafePipeModule, typeof DgpActionContextModule, typeof DgpInspectorModule, typeof DgpShortcutModule, typeof DgpNegatePipeModule], [typeof PdfViewerComponent, typeof JpgViewerComponent, typeof PngViewerComponent, typeof SvgViewerComponent, typeof FileViewerComponent, typeof FallbackFileViewerComponent, typeof FileItemListComponent, typeof DynamicFileViewerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpFileViewerModule>;
}

declare const openFileManagerOverlay: _ngrx_store.ActionCreator<"[FileUpload] OpenFileManagerOverlay", (props: {
    readonly config?: FileUploadConfig;
    readonly fileItems?: ReadonlyArray<FileItem>;
    readonly directories?: ReadonlyArray<Directory>;
    readonly selectedFileItemId?: string;
}) => {
    readonly config?: FileUploadConfig;
    readonly fileItems?: ReadonlyArray<FileItem>;
    readonly directories?: ReadonlyArray<Directory>;
    readonly selectedFileItemId?: string;
} & _ngrx_store.Action<"[FileUpload] OpenFileManagerOverlay">>;
declare const openFileManager: _ngrx_store.ActionCreator<"[FileUpload] OpenFileManagerOverlay", (props: {
    readonly config?: FileUploadConfig;
    readonly fileItems?: ReadonlyArray<FileItem>;
    readonly directories?: ReadonlyArray<Directory>;
    readonly selectedFileItemId?: string;
}) => {
    readonly config?: FileUploadConfig;
    readonly fileItems?: ReadonlyArray<FileItem>;
    readonly directories?: ReadonlyArray<Directory>;
    readonly selectedFileItemId?: string;
} & _ngrx_store.Action<"[FileUpload] OpenFileManagerOverlay">>;
declare const closeFileManager: _ngrx_store.ActionCreator<"[FileUpload] CloseFileManager", () => _ngrx_store.Action<"[FileUpload] CloseFileManager">>;
declare const addFilesViaDrop: _ngrx_store.ActionCreator<"[FileUpload] AddFiles", (props: {
    readonly fileItems: ReadonlyArray<FileItem>;
}) => {
    readonly fileItems: ReadonlyArray<FileItem>;
} & _ngrx_store.Action<"[FileUpload] AddFiles">>;
declare const addFiles: _ngrx_store.ActionCreator<"[FileUpload] AddFiles", (props: {
    readonly fileItems: ReadonlyArray<FileItem>;
}) => {
    readonly fileItems: ReadonlyArray<FileItem>;
} & _ngrx_store.Action<"[FileUpload] AddFiles">>;
declare const removeFile: _ngrx_store.ActionCreator<"[FileUpload] RemoveFile", (props: {
    readonly fileItem: FileItem;
}) => {
    readonly fileItem: FileItem;
} & _ngrx_store.Action<"[FileUpload] RemoveFile">>;
declare const downloadFile: _ngrx_store.ActionCreator<"[FileUpload] DownloadFile", (props: {
    readonly fileItem: FileItem;
}) => {
    readonly fileItem: FileItem;
} & _ngrx_store.Action<"[FileUpload] DownloadFile">>;
declare const showDropTarget: _ngrx_store.ActionCreator<"[FileUpload] ShowDropTarget", () => _ngrx_store.Action<"[FileUpload] ShowDropTarget">>;
declare const hideDropTarget: _ngrx_store.ActionCreator<"[FileUpload] HideDropTarget", () => _ngrx_store.Action<"[FileUpload] HideDropTarget">>;
declare const setConfig: _ngrx_store.ActionCreator<"[FileUpload] SetConfig", (props: {
    readonly config: FileUploadConfig;
}) => {
    readonly config: FileUploadConfig;
} & _ngrx_store.Action<"[FileUpload] SetConfig">>;
declare const selectPreviousFile: _ngrx_store.ActionCreator<"[FileUpload] SelectPreviousFile", () => _ngrx_store.Action<"[FileUpload] SelectPreviousFile">>;
declare const selectNextFile: _ngrx_store.ActionCreator<"[FileUpload] SelectNextFile", () => _ngrx_store.Action<"[FileUpload] SelectNextFile">>;
declare const setIsFileDrawerOpen: _ngrx_store.ActionCreator<"[FileUpload] SetIsFileDrawerOpen", (props: {
    readonly isDrawerOpen: boolean;
}) => {
    readonly isDrawerOpen: boolean;
} & _ngrx_store.Action<"[FileUpload] SetIsFileDrawerOpen">>;

declare class DragFileListenerDirective {
    private readonly store;
    private readonly elementRef;
    constructor(store: Store<any>, elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<DragFileListenerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DragFileListenerDirective, "[dgpFileDragListener]", never, {}, {}, never, never, false, never>;
}

declare class OpenFileManagerViaShortKeyDirective implements OnDestroy {
    private readonly store;
    private readonly moduleConfig;
    private readonly keyPressSubscription;
    constructor(store: Store<any>, moduleConfig: FileUploadConfig);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenFileManagerViaShortKeyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OpenFileManagerViaShortKeyDirective, "[dgpOpenFileManagerViaShortKey]", never, {}, {}, never, never, false, never>;
}

declare function parseFileNameWithExtension(fileNameWithExtension: string): {
    readonly extension: string;
    readonly fileName: string;
};
declare function getMimeTypeFromExtension(extension: string): string;
declare function getFileItemsFromFileList(fileList: FileList): ReadonlyArray<FileItem>;
declare function getFileFromFileItem$(fileItem: FileItem): Promise<File>;
declare function getFileFromUrl$(url: string): Promise<File>;
declare function parseContentAsStringMatrix(csvFileContent: string): any[];
declare function parseCSVFile$(fileToRead: File): Promise<Matrix<string>>;
declare function toFileItemActionContextKey(fileItem: FileItem): string;
declare function toFileItemActionContext(item: FileItem): ActionContext;

declare const fileUploadFeatureSelector: _ngrx_store.MemoizedSelector<object, FileUploadState, _ngrx_store.DefaultProjectorFn<FileUploadState>>;
declare const getFileItemState: _ngrx_store.MemoizedSelector<object, data_modeling.EntityState<FileItem>, (s1: FileUploadState) => data_modeling.EntityState<FileItem>>;
declare const getDirectoryState: _ngrx_store.MemoizedSelector<object, data_modeling.EntityState<dgp_ng_app.Directory>, (s1: FileUploadState) => data_modeling.EntityState<dgp_ng_app.Directory>>;
declare const getAllFileItems: _ngrx_store.MemoizedSelector<object, FileItem[], (s1: data_modeling.EntityState<FileItem>) => FileItem[]>;
declare const getFileItemKVS: _ngrx_store.MemoizedSelector<object, data_modeling.KeyValueStore<Readonly<FileItem>>, (s1: data_modeling.EntityState<FileItem>) => data_modeling.KeyValueStore<Readonly<FileItem>>>;
declare const getAllDirectories: _ngrx_store.MemoizedSelector<object, dgp_ng_app.Directory[], (s1: data_modeling.EntityState<dgp_ng_app.Directory>) => dgp_ng_app.Directory[]>;
declare const getFileItemListModel: _ngrx_store.MemoizedSelector<object, FileItemListModel, (s1: dgp_ng_app.Directory[], s2: data_modeling.KeyValueStore<Readonly<FileItem>>) => FileItemListModel>;
declare const getSelectedFileItem: _ngrx_store.MemoizedSelector<object, FileItem, (s1: any, s2: string) => FileItem>;
declare const hasMoreThanOneFile: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileItem[]) => boolean>;
declare const isFileManagerOpen: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;
declare const canOpenFileDrawer: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;
declare const isAddFilesDisabled: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;
declare const isRemoveFilesDisabled: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;
declare const isDropTargetVisible: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;
declare const canSelectPreviousFile: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileItem, s2: FileItem[]) => boolean>;
declare const canSelectNextFile: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileItem, s2: FileItem[]) => boolean>;
declare const isFileManagerMenuDrawerOpen: _ngrx_store.MemoizedSelector<object, boolean, (s1: FileUploadState) => boolean>;

declare const fileUploadEntityStore: entity_store.EntityStore<FileUploadEntities, "FileUpload">;

declare class FileManagerComponent extends DgpContainer<FileUploadState> {
    readonly isDropTargetVisible$: rxjs.Observable<boolean>;
    readonly canOpenFileDrawer$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileManagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileManagerComponent, "dgp-file-manager", never, {}, {}, never, never, false, never>;
}

declare class CurrentFileDropZoneComponent extends DgpContainer<FileUploadState> {
    readonly isAddFilesDisabled$: rxjs.Observable<boolean>;
    addFiles(fileItems: Many<FileItem>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentFileDropZoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentFileDropZoneComponent, "dgp-current-file-drop-zone", never, {}, {}, never, never, false, never>;
}

declare class FileDropZoneComponent extends DgpContainer<FileUploadState> implements AfterViewInit, OnDestroy {
    protected readonly store: Store<FileUploadState>;
    private readonly elementRef;
    disabled: boolean;
    readonly filesAdded: EventEmitter<Many<FileItem>>;
    readonly dragEnterHandler: (e: DragEvent) => void;
    readonly dragLeaveHandler: (e: DragEvent) => void;
    readonly dragOverHandler: (e: DragEvent) => void;
    readonly dropHandler: (e: DragEvent) => void;
    constructor(store: Store<FileUploadState>, elementRef: ElementRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onFileSelected(e: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileDropZoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileDropZoneComponent, "dgp-file-drop-zone", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "filesAdded": "filesAdded"; }, never, never, false, never>;
}

declare class CurrentFileItemListComponent extends DgpContainer<FileUploadState> {
    readonly fileItemListModel$: rxjs.Observable<dgp_ng_app.FileItemListModel>;
    readonly isRemoveFilesDisabled$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentFileItemListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentFileItemListComponent, "dgp-current-file-item-list", never, {}, {}, never, never, false, never>;
}

declare class CurrentAddFileListItemComponent extends DgpContainer<FileUploadState> {
    readonly isAddFilesDisabled$: rxjs.Observable<boolean>;
    onFileSelected(e: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentAddFileListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentAddFileListItemComponent, "dgp-current-add-file-list-item", never, {}, {}, never, never, false, never>;
}

declare class FileManagerDialogHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileManagerDialogHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileManagerDialogHeaderComponent, "dgp-file-manager-dialog-header", never, {}, {}, never, never, false, never>;
}

declare class CurrentFileViewerComponent extends DgpContainer<FileUploadState> {
    readonly selectedFileItem$: rxjs.Observable<dgp_ng_app.FileItem>;
    readonly hasMoreThanOneFile$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentFileViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentFileViewerComponent, "dgp-current-file-viewer", never, {}, {}, never, never, false, never>;
}

declare class CurrentListFileViewerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentListFileViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentListFileViewerComponent, "dgp-current-list-file-viewer", never, {}, {}, never, never, false, never>;
}

declare class CloseDialogButtonComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CloseDialogButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CloseDialogButtonComponent, "dgp-close-dialog-button", never, {}, {}, never, never, false, never>;
}

declare class MaximizeDialogButtonComponent {
    private readonly dialogRef;
    private readonly moduleConfig;
    isMaximized: boolean;
    constructor(dialogRef: MatDialogRef<any>, moduleConfig: FileUploadConfig);
    maximize(): void;
    minimize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MaximizeDialogButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MaximizeDialogButtonComponent, "dgp-maximize-dialog-button", never, {}, {}, never, never, false, never>;
}

interface RequestState {
    readonly pendingRequests: number;
}
interface RequestStoreState {
    readonly requests: RequestState;
}
declare const requestStoreFeature = "Requests";

declare class PageHeaderComponent extends DgpContainer<RequestState> {
    readonly hasPendingRequests$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageHeaderComponent, "dgp-page-header", never, {}, {}, never, ["*"], false, never>;
}

declare class DgpPageHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpPageHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpPageHeaderModule, [typeof PageHeaderComponent], [typeof i4$1.CommonModule, typeof i2$2.MatToolbarModule, typeof i4$2.MatProgressBarModule], [typeof PageHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpPageHeaderModule>;
}

declare class ListDetailsPageContentComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListDetailsPageContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListDetailsPageContentComponent, "dgp-list-details-page-content", never, {}, {}, never, ["*"], false, never>;
}

declare enum HamburgerShellMode {
    Responsive = 0,
    Overlay = 1,
    SideNav = 2
}
declare enum ListDetailsPageMode {
    Responsive = 0,
    Overlay = 1,
    SideNav = 2
}
interface HamburgerShellConfig {
    readonly hamburgerShellMode: HamburgerShellMode;
    readonly hamburgerMenuBreakpoints?: ReadonlyArray<string>;
    readonly listDetailsPageMode: ListDetailsPageMode;
    readonly listDetailsPageMenuBreakpoints?: ReadonlyArray<string>;
}
declare const responsiveHamburgerShellConfig: HamburgerShellConfig;
declare const sideNavHamburgerShellConfig: HamburgerShellConfig;
declare const overlayHamburgerShellConfig: HamburgerShellConfig;
declare const defaultHamburgerShellConfig: HamburgerShellConfig;
declare const HAMBURGER_SHELL_CONFIG: InjectionToken<HamburgerShellConfig>;
interface HamburgerShellConfigProvider extends ValueProvider {
    provide: typeof HAMBURGER_SHELL_CONFIG;
}
declare const sideNavHamburgerShellConfigProvider: HamburgerShellConfigProvider;
declare const overlayHamburgerShellConfigProvider: HamburgerShellConfigProvider;
declare const defaultHamburgerShellConfigProvider: HamburgerShellConfigProvider;
type HamburgerMenuMode = "side" | "over";
type PageMenuMode = DrawerMode;
interface HamburgerShellState {
    readonly isHamburgerMenuOpen: boolean;
    readonly hamburgerMenuMode: HamburgerMenuMode;
    readonly isPageMenuOpen: boolean;
    readonly pageMenuMode: PageMenuMode;
}
declare const hamburgerShellStoreFeature = "HamburgerShell";

declare class ListDetailsPageComponent extends DgpContainer<HamburgerShellState> {
    menuTogglePosition: DrawerLayoutMenuTogglePosition;
    readonly pageMenuDrawerMode$: rxjs.Observable<dgp_ng_app.DrawerMode>;
    readonly isPageMenuDrawerOpen$: rxjs.Observable<boolean>;
    closePageMenuDrawer(isOpen: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListDetailsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListDetailsPageComponent, "dgp-list-details-page", never, { "menuTogglePosition": { "alias": "menuTogglePosition"; "required": false; }; }, {}, never, ["[dgp-list-details-page-menu]", "*"], false, never>;
}

declare class DgpListDetailsPageMenuToggleComponent extends DgpContainer<HamburgerShellState> {
    readonly isPageMenuDrawerOpen$: rxjs.Observable<boolean>;
    togglePageMenuDrawer(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpListDetailsPageMenuToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpListDetailsPageMenuToggleComponent, "dgp-list-details-page-menu-toggle", never, {}, {}, never, never, true, never>;
}

declare class DgpDrawerLayoutComponent implements DrawerLayout, IsDrawerOpenInfoProperty {
    readonly togglePositionEnum: typeof DrawerLayoutMenuTogglePosition;
    menuTogglePosition: DrawerLayoutMenuTogglePosition;
    drawerMode: DrawerMode;
    isDrawerOpen: boolean;
    readonly isDrawerOpenChange: EventEmitter<boolean>;
    closeMenuDrawer(): void;
    updateIsDrawerOpen(isDrawerOpen: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDrawerLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpDrawerLayoutComponent, "dgp-drawer-layout", never, { "menuTogglePosition": { "alias": "menuTogglePosition"; "required": false; }; "drawerMode": { "alias": "drawerMode"; "required": false; }; "isDrawerOpen": { "alias": "isDrawerOpen"; "required": false; }; }, { "isDrawerOpenChange": "isDrawerOpenChange"; }, never, ["[dgp-drawer-layout-menu]", "*"], true, never>;
}

declare class DgpListDetailsPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpListDetailsPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpListDetailsPageModule, [typeof ListDetailsPageContentComponent, typeof ListDetailsPageComponent], [typeof i4$1.CommonModule, typeof i3$1.MatButtonModule, typeof i4.MatIconModule, typeof i6.MatSidenavModule, typeof i9.MatTooltipModule, typeof DgpListDetailsPageMenuToggleComponent, typeof DgpDrawerLayoutComponent], [typeof ListDetailsPageContentComponent, typeof ListDetailsPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpListDetailsPageModule>;
}

declare class DgpSelectPreviousFileItemActionComponent extends DgpContainer<FileUploadState> {
    readonly canSelectPreviousFile$: rxjs.Observable<boolean>;
    selectPreviousFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpSelectPreviousFileItemActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpSelectPreviousFileItemActionComponent, "dgp-select-previous-file-item-action", never, {}, {}, never, never, true, never>;
}

declare class DgpSelectNextFileItemActionComponent extends DgpContainer<FileUploadState> {
    readonly canSelectNextFile$: rxjs.Observable<boolean>;
    selectNextFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpSelectNextFileItemActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpSelectNextFileItemActionComponent, "dgp-select-next-file-item-action", never, {}, {}, never, never, true, never>;
}

declare class DgpDrawerLayoutMenuToggleComponent implements ActionShortcut, IsDrawerOpenInfoProperty {
    readonly isDrawerOpenChange: EventEmitter<boolean>;
    isDrawerOpen: boolean;
    shortcutKey: string;
    requireAlt: boolean;
    requireCtrl: boolean;
    requireShift: boolean;
    toggleDrawer(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpDrawerLayoutMenuToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpDrawerLayoutMenuToggleComponent, "dgp-drawer-layout-menu-toggle", never, { "isDrawerOpen": { "alias": "isDrawerOpen"; "required": false; }; "shortcutKey": { "alias": "shortcutKey"; "required": false; }; "requireAlt": { "alias": "requireAlt"; "required": false; }; "requireCtrl": { "alias": "requireCtrl"; "required": false; }; "requireShift": { "alias": "requireShift"; "required": false; }; }, { "isDrawerOpenChange": "isDrawerOpenChange"; }, never, never, true, never>;
}

declare class DgpFileManagerDrawerLayout extends DgpContainer<FileUploadState> {
    readonly togglePositionEnum: typeof DrawerLayoutMenuTogglePosition;
    readonly drawerModeEnum: typeof DrawerMode;
    readonly isFileManagerMenuDrawerOpen$: rxjs.Observable<boolean>;
    setIsFileDrawerOpen(isDrawerOpen: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpFileManagerDrawerLayout, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpFileManagerDrawerLayout, "dgp-file-manager-drawer-layout", never, {}, {}, never, ["[dgp-file-manager-file-menu]", "*"], true, never>;
}

declare class DgpFileManagerMenuToggle extends DgpContainer<FileUploadState> {
    readonly isFileManagerMenuDrawerOpen$: rxjs.Observable<boolean>;
    setIsFileDrawerOpen(isDrawerOpen: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpFileManagerMenuToggle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpFileManagerMenuToggle, "dgp-file-manager-menu-toggle", never, {}, {}, never, never, true, never>;
}

declare class DgpFileUploadModule {
    static forRoot(config?: dgp_ng_app.FileUploadConfig): ModuleWithProviders<DgpFileUploadModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpFileUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpFileUploadModule, [typeof FileManagerComponent, typeof CurrentFileDropZoneComponent, typeof FileDropZoneComponent, typeof CurrentFileItemListComponent, typeof CurrentAddFileListItemComponent, typeof FileManagerDialogHeaderComponent, typeof CurrentFileViewerComponent, typeof CurrentListFileViewerComponent, typeof CloseDialogButtonComponent, typeof MaximizeDialogButtonComponent, typeof DragFileListenerDirective, typeof OpenFileManagerViaShortKeyDirective], [typeof i4$1.CommonModule, typeof i2$1.MatDialogModule, typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule, typeof DgpPageHeaderModule, typeof DgpListDetailsPageModule, typeof i5.MatListModule, typeof i15.RouterModule, typeof i4.MatIconModule, typeof DgpSpacerModule, typeof i3$1.MatButtonModule, typeof i21.MatMenuModule, typeof DgpEmptyStateModule, typeof i9.MatTooltipModule, typeof DgpFileViewerModule, typeof DgpShortcutModule, typeof DgpNegatePipeModule, typeof DgpListDetailsPageMenuToggleComponent, typeof DgpSelectPreviousFileItemActionComponent, typeof DgpSelectNextFileItemActionComponent, typeof DgpDrawerLayoutComponent, typeof DgpDrawerLayoutMenuToggleComponent, typeof DgpFileManagerDrawerLayout, typeof DgpFileManagerMenuToggle], [typeof DragFileListenerDirective, typeof OpenFileManagerViaShortKeyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpFileUploadModule>;
}

declare const setHamburgerMenuState: _ngrx_store.ActionCreator<"[HamburgerShell] SetHamburgerMenuState", (props: {
    readonly isHamburgerMenuOpen: boolean;
    readonly hamburgerMenuMode: HamburgerMenuMode;
}) => {
    readonly isHamburgerMenuOpen: boolean;
    readonly hamburgerMenuMode: HamburgerMenuMode;
} & _ngrx_store.Action<"[HamburgerShell] SetHamburgerMenuState">>;
declare const toggleHamburgerMenu: _ngrx_store.ActionCreator<"[HamburgerShell] ToggleHamburgerMenu", () => _ngrx_store.Action<"[HamburgerShell] ToggleHamburgerMenu">>;
declare const closeHamburgerMenu: _ngrx_store.ActionCreator<"[HamburgerShell] CloseHamburgerMenu", () => _ngrx_store.Action<"[HamburgerShell] CloseHamburgerMenu">>;
declare const setListDetailsPageState: _ngrx_store.ActionCreator<"[HamburgerShell] SetListDetailsPageState", (props: {
    readonly isPageMenuOpen: boolean;
    readonly pageMenuMode: PageMenuMode;
}) => {
    readonly isPageMenuOpen: boolean;
    readonly pageMenuMode: PageMenuMode;
} & _ngrx_store.Action<"[HamburgerShell] SetListDetailsPageState">>;
declare const toggleListDetailsPageMenu: _ngrx_store.ActionCreator<"[HamburgerShell] ToggleListDetailsPageMenu", () => _ngrx_store.Action<"[HamburgerShell] ToggleListDetailsPageMenu">>;
declare const closeListDetailsMenu: _ngrx_store.ActionCreator<"[HamburgerShell] CloseListDetailsPageMenu", () => _ngrx_store.Action<"[HamburgerShell] CloseListDetailsPageMenu">>;

declare class HamburgerShellComponent {
    private readonly store;
    readonly hasPendingRequests$: rxjs.Observable<boolean>;
    readonly isHamburgerMenuOpen$: rxjs.Observable<boolean>;
    readonly hamburgerMenuMode$: rxjs.Observable<dgp_ng_app.HamburgerMenuMode>;
    constructor(store: Store<HamburgerShellState>);
    closeHamburgerMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerShellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerShellComponent, "dgp-hamburger-shell", never, {}, {}, never, ["[dgp-hamburger-menu]", "*"], false, never>;
}

declare class HamburgerMenuToggleComponent extends DgpContainer<HamburgerShellState> {
    toggleHamburgerMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerMenuToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerMenuToggleComponent, "dgp-hamburger-menu-toggle", never, {}, {}, never, never, false, never>;
}

declare class DgpHamburgerMenuToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpHamburgerMenuToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpHamburgerMenuToggleModule, [typeof HamburgerMenuToggleComponent], [typeof i4$1.CommonModule, typeof i3$1.MatButtonModule, typeof i4.MatIconModule, typeof DgpShortcutModule, typeof i9.MatTooltipModule], [typeof HamburgerMenuToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpHamburgerMenuToggleModule>;
}

declare class HamburgerMenuComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerMenuComponent, "dgp-hamburger-menu", never, {}, {}, never, ["*"], false, never>;
}

declare class HamburgerMenuHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerMenuHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerMenuHeaderComponent, "dgp-hamburger-menu-header", never, {}, {}, never, ["*"], false, never>;
}

declare class HamburgerMenuEntriesComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerMenuEntriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerMenuEntriesComponent, "dgp-hamburger-menu-entries", never, {}, {}, never, ["*"], false, never>;
}

declare class HamburgerMenuEntryComponent {
    matIconName: string;
    label: string;
    route: any;
    disabled: any;
    isNonEmptyRoute(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerMenuEntryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerMenuEntryComponent, "dgp-hamburger-menu-entry", never, { "matIconName": { "alias": "matIconName"; "required": false; }; "label": { "alias": "label"; "required": false; }; "route": { "alias": "route"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpHamburgerMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpHamburgerMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpHamburgerMenuModule, [typeof HamburgerMenuComponent, typeof HamburgerMenuHeaderComponent, typeof HamburgerMenuEntriesComponent, typeof HamburgerMenuEntryComponent], [typeof i2$2.MatToolbarModule, typeof i5.MatListModule, typeof i15.RouterModule, typeof i4.MatIconModule, typeof i4$1.CommonModule], [typeof HamburgerMenuComponent, typeof HamburgerMenuHeaderComponent, typeof HamburgerMenuEntriesComponent, typeof HamburgerMenuEntryComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpHamburgerMenuModule>;
}

declare const hamburgerShellFeatureSelector: _ngrx_store.MemoizedSelector<object, HamburgerShellState, _ngrx_store.DefaultProjectorFn<HamburgerShellState>>;
declare const hamburgerMenuModeSelector: _ngrx_store.MemoizedSelector<object, dgp_ng_app.HamburgerMenuMode, (s1: HamburgerShellState) => dgp_ng_app.HamburgerMenuMode>;
declare const isHamburgerMenuOpenSelector: _ngrx_store.MemoizedSelector<object, boolean, (s1: HamburgerShellState) => boolean>;
declare const pageMenuModeSelector: _ngrx_store.MemoizedSelector<object, dgp_ng_app.DrawerMode, (s1: HamburgerShellState) => dgp_ng_app.DrawerMode>;
declare const isPageMenuOpenSelector: _ngrx_store.MemoizedSelector<object, boolean, (s1: HamburgerShellState) => boolean>;

declare class DgpHamburgerShellModule {
    static forRoot(configProvider?: HamburgerShellConfigProvider): ModuleWithProviders<DgpHamburgerShellModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpHamburgerShellModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpHamburgerShellModule, [typeof HamburgerShellComponent], [typeof i2$3.LayoutModule, typeof i4$1.CommonModule, typeof i6$1.FormsModule, typeof i3$1.MatButtonModule, typeof i4.MatIconModule, typeof i4$2.MatProgressBarModule, typeof i6.MatSidenavModule, typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule, typeof i15.RouterModule], [typeof HamburgerShellComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpHamburgerShellModule>;
}

declare const hotReload: _ngrx_store.ActionCreator<"[HMR] Reload", (props: {
    readonly payload: any;
}) => {
    readonly payload: any;
} & _ngrx_store.Action<"[HMR] Reload">>;

/**
 * Generate a reducer to set the root state in dev mode for HMR
 */
declare function hmrReducer(x: ActionReducer<any>): ActionReducer<any>;

declare class DgpNgApp {
    readonly appRef: ApplicationRef;
    protected readonly ngrxStore: Store<any>;
    constructor(appRef: ApplicationRef, ngrxStore: Store<any>);
    hmrOnInit(store: any): void;
    hmrOnDestroy(store: any): void;
    hmrAfterDestroy(store: any): void;
}

declare class DgpInputErrorInfoComponent extends DgpView<any> {
    metadata: AttributeMetadata<any>;
    readonly metadata$: rxjs.Observable<AttributeMetadata<any, number>>;
    readonly validationResult$: rxjs.Observable<ModelValidationResult>;
    readonly hasErrors$: rxjs.Observable<boolean>;
    readonly firstErrorMessage$: rxjs.Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputErrorInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInputErrorInfoComponent, "dgp-input-error-info", never, { "metadata": { "alias": "metadata"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpInputFieldComponent extends DgpView<any> implements InspectorConfig {
    metadata: AttributeMetadata<any>;
    fieldLabelThemeColor: ThemePalette;
    maxContentWidth: string;
    showFieldDescriptions: boolean | "onHover";
    showFieldIcons: boolean;
    responsive: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInputFieldComponent, "dgp-input-field", never, { "metadata": { "alias": "metadata"; "required": false; }; "fieldLabelThemeColor": { "alias": "fieldLabelThemeColor"; "required": false; }; "maxContentWidth": { "alias": "maxContentWidth"; "required": false; }; "showFieldDescriptions": { "alias": "showFieldDescriptions"; "required": false; }; "showFieldIcons": { "alias": "showFieldIcons"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class DgpInputHintComponent extends DgpView<any> {
    metadata: AttributeMetadata<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputHintComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInputHintComponent, "dgp-input-hint", never, { "metadata": { "alias": "metadata"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpInputLengthInfoComponent extends DgpView<string> {
    metadata: AttributeMetadata<string>;
    readonly metadata$: rxjs.Observable<AttributeMetadata<string, number>>;
    readonly hasMax$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputLengthInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInputLengthInfoComponent, "dgp-input-length-info", never, { "metadata": { "alias": "metadata"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpInputMetadataDirective implements OnChanges {
    private readonly elementRef;
    private readonly renderer;
    metadata: AttributeMetadata<any>;
    constructor(elementRef: ElementRef<HTMLInputElement>, renderer: Renderer2);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputMetadataDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpInputMetadataDirective, "[dgpInputMetadata]", never, { "metadata": { "alias": "metadata"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpInputFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInputFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpInputFieldModule, [typeof DgpInputErrorInfoComponent, typeof DgpInputFieldComponent, typeof DgpInputHintComponent, typeof DgpInputLengthInfoComponent, typeof DgpInputMetadataDirective], [typeof i4$1.CommonModule, typeof i6$1.FormsModule, typeof i8.MatSlideToggleModule, typeof DgpSpacerModule, typeof i4.MatIconModule, typeof DgpInspectorModule], [typeof DgpInputErrorInfoComponent, typeof DgpInputFieldComponent, typeof DgpInputHintComponent, typeof DgpInputLengthInfoComponent, typeof DgpInputMetadataDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpInputFieldModule>;
}

declare const inspectorDefaultConfig: InspectorConfig;

declare const DEFAULT_INSPECTOR_CONFIG: InjectionToken<InspectorConfig>;

declare const inspectorConfigMetadata: ModelMetadata<InspectorConfig>;

declare function provideDefaultInspectorConfig(payload: Partial<InspectorConfig>): Provider;

declare class DgpInspectorConfigFormComponent extends DgpModelEditorComponentBase<InspectorConfig> {
    readonly inspectorConfigMetadata: data_modeling.ModelMetadata<InspectorConfig, data_modeling.KVS<InspectorConfig>>;
    readonly maxContentWidth$: rxjs.Observable<number>;
    updateShowFieldDescription(showFieldDescriptions: boolean | "onHover"): void;
    updateResponsive(responsive: boolean): void;
    updateShowFieldIcons(showFieldIcons: boolean): void;
    updateFieldLabelThemeColor(fieldLabelThemeColor: ThemePalette): void;
    updateMaxContentWidth(maxContentWidth: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInspectorConfigFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInspectorConfigFormComponent, "dgp-inspector-config-form", never, {}, {}, never, never, false, never>;
}

declare class DgpInspectorConfigComponent extends DgpContainer<ThemeSwitcherState> {
    readonly inspectorConfig$: rxjs.Observable<InspectorConfig>;
    updateInspectorConfig(inspectorConfig: InspectorConfig): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInspectorConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpInspectorConfigComponent, "dgp-inspector-config", never, {}, {}, never, never, false, never>;
}

declare class DgpInspectorConfigModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpInspectorConfigModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpInspectorConfigModule, [typeof DgpInspectorConfigFormComponent, typeof DgpInspectorConfigComponent], [typeof DgpInspectorModule, typeof i4$1.NgIf, typeof i8.MatSlideToggleModule, typeof i6$1.FormsModule, typeof i7.MatFormFieldModule, typeof i8$1.MatSelectModule, typeof i4$1.AsyncPipe, typeof i9$1.MatInputModule, typeof i10.MatSliderModule, typeof DgpSpacerModule], [typeof DgpInspectorConfigFormComponent, typeof DgpInspectorConfigComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpInspectorConfigModule>;
}

declare enum LazyRenderedContentDisplayStrategy {
    WhileInView = "whileInView"
}
declare class DgpLazyRenderedComponent implements AfterViewInit, OnDestroy {
    private readonly elRef;
    private readonly cd;
    private showContentSubscription;
    private saveLastHeightSubscription;
    private intersectionObserver;
    private lastSavedHeight;
    contentTemplateRef: TemplateRef<any>;
    placeholderTemplateRef: TemplateRef<any>;
    currentTemplateRef: TemplateRef<any>;
    /**
     * default: parent element
     */
    displayRegionSelector: string;
    showContent: boolean;
    contentDisplayStrategy: LazyRenderedContentDisplayStrategy;
    private readonly showContent$;
    private readonly heightScheduler;
    constructor(elRef: ElementRef<HTMLElement>, cd: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private checkIntersectionWithDisplayRegion;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpLazyRenderedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpLazyRenderedComponent, "dgp-lazy-rendered", never, { "displayRegionSelector": { "alias": "displayRegionSelector"; "required": false; }; "contentDisplayStrategy": { "alias": "contentDisplayStrategy"; "required": false; }; }, {}, ["contentTemplateRef", "placeholderTemplateRef"], ["*"], false, never>;
}

declare class DgpLazyRenderedContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpLazyRenderedContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpLazyRenderedContentDirective, "[dgpLazyRenderedContent], [dgp-lazy-rendered-content]", never, {}, {}, never, never, false, never>;
}

declare class DgpLazyRenderedPlaceholderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpLazyRenderedPlaceholderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpLazyRenderedPlaceholderDirective, "[dgpLazyRenderedPlaceholder], [dgp-lazy-rendered-placeholder]", never, {}, {}, never, never, false, never>;
}

declare class DgpLazyRenderedModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpLazyRenderedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpLazyRenderedModule, [typeof DgpLazyRenderedComponent, typeof DgpLazyRenderedContentDirective, typeof DgpLazyRenderedPlaceholderDirective], [typeof i4$3.DialogModule, typeof i4$1.NgTemplateOutlet], [typeof DgpLazyRenderedComponent, typeof DgpLazyRenderedContentDirective, typeof DgpLazyRenderedPlaceholderDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpLazyRenderedModule>;
}

declare enum Severity {
    Error = 0
}
interface LogEntry {
    readonly timeStamp: number;
    readonly title: string;
    readonly content?: any;
    readonly severity: Severity;
}
interface LogStoreSchema {
    readonly logEntry: LogEntry;
}
interface LogState extends EntityStateMap<LogStoreSchema> {
}
type LogStoreFeature = "LogStore";
declare const logStoreFeature: LogStoreFeature;

interface LogErrorPayload {
    readonly title: string;
    readonly error?: any;
}
declare const logError: _ngrx_store.ActionCreator<"[Log] LogError", (props: {
    readonly payload: LogErrorPayload;
}) => {
    readonly payload: LogErrorPayload;
} & Action$1<"[Log] LogError">>;
declare const addLogEntry: _ngrx_store.ActionCreator<"[Log] AddLogEntry", (props: {
    readonly logEntry: LogEntry;
}) => {
    readonly logEntry: LogEntry;
} & Action$1<"[Log] AddLogEntry">>;
declare const logErrorActionType: "[Log] LogError";
declare class LogErrorAction implements Action$1 {
    readonly payload: LogErrorPayload;
    readonly type: "[Log] LogError";
    constructor(payload: LogErrorPayload);
}

declare class LogEntryDetailsComponent {
    readonly severityEnum: typeof Severity;
    logEntry: LogEntry;
    isApiError(): boolean;
    isHtml(logEntry: LogEntry): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogEntryDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogEntryDetailsComponent, "dgp-log-entry-details", never, { "logEntry": { "alias": "logEntry"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LogEntryListComponent extends DgpContainer<LogState> {
    readonly severityEnum: typeof Severity;
    readonly logEntries$: rxjs.Observable<dgp_ng_app.LogEntry[]>;
    readonly hasLogEntries$: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogEntryListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogEntryListComponent, "dgp-log-entry-list", never, {}, {}, never, never, false, never>;
}

declare class LogPageComponent {
    private readonly store;
    private readonly activatedRoute;
    readonly logEntry$: rxjs.Observable<dgp_ng_app.LogEntry>;
    constructor(store: Store<LogState>, activatedRoute: ActivatedRoute);
    static ɵfac: i0.ɵɵFactoryDeclaration<LogPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogPageComponent, "dgp-log-page", never, {}, {}, never, never, false, never>;
}

declare class DgpLogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpLogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpLogModule, [typeof LogEntryDetailsComponent, typeof LogEntryListComponent, typeof LogPageComponent], [typeof i4$1.CommonModule, typeof i6$1.FormsModule, typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule, typeof i15.RouterModule, typeof i9$2.MatDividerModule, typeof i4.MatIconModule, typeof i5.MatListModule, typeof i3.MatSnackBarModule, typeof DgpHamburgerMenuToggleModule, typeof DgpPageHeaderModule, typeof DgpListDetailsPageModule, typeof DgpEmptyStateModule, typeof SafePipeModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpLogModule>;
}

declare const scheduleRequestActionType = "[ScheduleRequest] ScheduleRequestAction";
interface ScheduleRequestActionPayload<T> {
    /**
     * The request to be processed.
     *
     * Observables are converted into promises
     */
    request$: Promise<T> | Observable<T>;
}
declare class ScheduleRequestAction<T> implements Action$1 {
    readonly payload: ScheduleRequestActionPayload<T>;
    readonly type = "[ScheduleRequest] ScheduleRequestAction";
    constructor(payload: ScheduleRequestActionPayload<T>);
}
declare const scheduleRequest: _ngrx_store.ActionCreator<"[ScheduleRequest] ScheduleRequestAction", (props: ScheduleRequestActionPayload<any>) => ScheduleRequestActionPayload<any> & Action$1<"[ScheduleRequest] ScheduleRequestAction">>;

declare const requestStateSelector: _ngrx_store.MemoizedSelector<object, RequestStoreState, _ngrx_store.DefaultProjectorFn<RequestStoreState>>;
declare const hasPendingRequests: _ngrx_store.MemoizedSelector<object, boolean, (s1: RequestStoreState) => boolean>;
declare const hasPendingRequestsSelector: _ngrx_store.MemoizedSelector<object, boolean, (s1: boolean) => boolean>;

declare class DgpRequestStoreModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpRequestStoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpRequestStoreModule, never, [typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpRequestStoreModule>;
}

interface Size {
    readonly width: number;
    readonly height: number;
}

interface ResizeSensorConfig {
    readonly stableTime: number;
}
declare const defaultResizeSensorConfig: ResizeSensorConfig;
declare class ResizeSensor {
    private readonly element;
    private readonly callback;
    private readonly resizeActionScheduler;
    private resizeObserver;
    private resizeSubscription;
    private config;
    constructor(element: HTMLElement, callback: (size: Size) => void);
    configure(payload: ResizeSensorConfig): void;
    connect(): void;
    disconnect(): void;
    private initResizeSensor;
    protected scheduleResizeAction(size: Size): void;
}

declare class DgpResizeSensorDirective implements AfterViewInit, OnDestroy, ResizeSensorConfig {
    private readonly elRef;
    private readonly ngZone;
    private sensor;
    stableTime: number;
    readonly sizeChanged: EventEmitter<Size>;
    constructor(elRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpResizeSensorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpResizeSensorDirective, "[dgpResizeSensor]", never, { "stableTime": { "alias": "stableTime"; "required": false; }; }, { "sizeChanged": "sizeChanged"; }, never, never, false, never>;
}

declare class DgpResizeSensorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpResizeSensorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpResizeSensorModule, [typeof DgpResizeSensorDirective], never, [typeof DgpResizeSensorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpResizeSensorModule>;
}

declare const showLoadingSpinner: _ngrx_store.ActionCreator<"[RoutingOverlay] ShowSpinner", (props: {
    readonly showSpinner: boolean;
}) => {
    readonly showSpinner: boolean;
} & _ngrx_store.Action<"[RoutingOverlay] ShowSpinner">>;

declare class RoutingOverlayComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RoutingOverlayComponent, "dgp-routing-overlay", never, {}, {}, never, never, false, never>;
}

declare class DgpRoutingOverlayModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpRoutingOverlayModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpRoutingOverlayModule, [typeof RoutingOverlayComponent], [typeof i2$1.MatDialogModule, typeof i4$2.MatProgressBarModule, typeof i2.EffectsFeatureModule, typeof i5$1.MatProgressSpinnerModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpRoutingOverlayModule>;
}

declare class DgpTableCellEditorService {
    private currentEditor;
    cacheCurrentEditor(editor: MatDialogRef<any>): void;
    closeCurrentEditor(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTableCellEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DgpTableCellEditorService>;
}

declare class DgpTableCellComponent {
    private readonly matDialog;
    private readonly service;
    editDialogConfig: MatDialogConfig;
    readonly editorOpened: EventEmitter<any>;
    readonly editorClosed: EventEmitter<any>;
    disabled: boolean;
    scrollParentSelector: string;
    editorTemplate: TemplateRef<any>;
    buttonElRef: ElementRef;
    private dialogRef;
    constructor(matDialog: MatDialog, service: DgpTableCellEditorService);
    openCellEditorDialog(): Promise<void>;
    closeCellEditorDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpTableCellComponent, "dgp-table-cell", never, { "editDialogConfig": { "alias": "editDialogConfig"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "scrollParentSelector": { "alias": "scrollParentSelector"; "required": false; }; }, { "editorOpened": "editorOpened"; "editorClosed": "editorClosed"; }, ["editorTemplate"], ["*"], false, never>;
}

declare class DgpTableCellEditorComponent {
    readonly template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTableCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DgpTableCellEditorComponent, "dgp-table-cell-editor", never, {}, {}, never, never, false, never>;
}

declare class DgpTableCelLEditorDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTableCelLEditorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpTableCelLEditorDirective, "[dgpTableCellEditor]", never, {}, {}, never, never, false, never>;
}

declare class DgpCloseTableCellEditorDirective {
    private readonly service;
    disabled: boolean;
    constructor(service: DgpTableCellEditorService);
    closeDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpCloseTableCellEditorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpCloseTableCellEditorDirective, "[dgpCloseTableCellEditor]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpTableCellModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTableCellModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpTableCellModule, [typeof DgpTableCellComponent, typeof DgpTableCelLEditorDirective, typeof DgpCloseTableCellEditorDirective, typeof DgpTableCellEditorComponent], [typeof i4$1.CommonModule, typeof i3$1.MatButtonModule, typeof i2$1.MatDialogModule], [typeof DgpTableCellComponent, typeof DgpTableCelLEditorDirective, typeof DgpCloseTableCellEditorDirective, typeof DgpTableCellEditorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpTableCellModule>;
}

declare const toggleDarkMode: _ngrx_store.ActionCreator<"[ThemeSwitcher] ToggleDarkMode", () => _ngrx_store.Action<"[ThemeSwitcher] ToggleDarkMode">>;
declare const setIsDarkModeActive: _ngrx_store.ActionCreator<"[ThemeSwitcher] SetIsDarkModeActive", (props: {
    readonly isDarkModeActive: boolean;
}) => {
    readonly isDarkModeActive: boolean;
} & _ngrx_store.Action<"[ThemeSwitcher] SetIsDarkModeActive">>;
declare const toggleCompactTheme: _ngrx_store.ActionCreator<"[ThemeSwitcher] ToggleCompactTheme", () => _ngrx_store.Action<"[ThemeSwitcher] ToggleCompactTheme">>;

declare class CompactThemeToggleComponent extends DgpContainer<ThemeSwitcherState> {
    readonly isCompactThemeActive$: rxjs.Observable<boolean>;
    toggleCompactTheme(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompactThemeToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CompactThemeToggleComponent, "dgp-compact-theme-toggle", never, {}, {}, never, never, false, never>;
}

declare class DarkModeToggleComponent extends DgpContainer<ThemeSwitcherState> {
    readonly useDarkMode$: rxjs.Observable<boolean>;
    toggleDarkMode(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DarkModeToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DarkModeToggleComponent, "dgp-dark-mode-toggle", never, {}, {}, never, never, false, never>;
}

declare class DgpCompactThemeHostDirective implements AfterViewInit {
    private readonly elRef;
    private readonly renderer;
    private readonly config;
    private readonly overlayContainer;
    constructor(elRef: ElementRef, renderer: Renderer2, config: ThemeSwitcherConfig, overlayContainer: OverlayContainer);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpCompactThemeHostDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpCompactThemeHostDirective, "[dgpCompactThemeHost]", never, {}, {}, never, never, false, never>;
}

declare class ThemeHostDirective {
    private readonly elRef;
    private readonly renderer;
    private readonly store;
    private readonly config;
    private readonly overlayContainer;
    constructor(elRef: ElementRef, renderer: Renderer2, store: Store<ThemeSwitcherState>, config: ThemeSwitcherConfig, overlayContainer: OverlayContainer);
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeHostDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeHostDirective, "[dgpThemeHost]", never, {}, {}, never, never, false, never>;
}

declare const themeSwitcherFeatureSelector: _ngrx_store.MemoizedSelector<object, ThemeSwitcherState, _ngrx_store.DefaultProjectorFn<ThemeSwitcherState>>;
declare const isDarkModeActiveSelector: _ngrx_store.MemoizedSelector<object, boolean, (s1: ThemeSwitcherState) => boolean>;
declare const isDarkModeActive: _ngrx_store.MemoizedSelector<object, boolean, (s1: ThemeSwitcherState) => boolean>;
declare const isCompactThemeActive: _ngrx_store.MemoizedSelector<object, boolean, (s1: ThemeSwitcherState) => boolean>;

declare class DgpThemeSwitcherModule {
    private readonly store;
    private readonly themeSwitcherConfig;
    static forRoot(config?: Partial<ThemeSwitcherConfig>): ModuleWithProviders<DgpThemeSwitcherModule>;
    constructor(store: Store<ThemeSwitcherState>, themeSwitcherConfig: ThemeSwitcherConfig);
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpThemeSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpThemeSwitcherModule, [typeof DarkModeToggleComponent, typeof ThemeHostDirective, typeof DgpCompactThemeHostDirective, typeof CompactThemeToggleComponent], [typeof i4$1.CommonModule, typeof i6$1.FormsModule, typeof i7$1.OverlayModule, typeof i8.MatSlideToggleModule, typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule], [typeof DarkModeToggleComponent, typeof ThemeHostDirective, typeof DgpCompactThemeHostDirective, typeof CompactThemeToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpThemeSwitcherModule>;
}

declare class TileComponent {
    externalLink: string;
    route: string;
    matIconName: string;
    label: string;
    description: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TileComponent, "dgp-tile", never, { "externalLink": { "alias": "externalLink"; "required": false; }; "route": { "alias": "route"; "required": false; }; "matIconName": { "alias": "matIconName"; "required": false; }; "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DgpTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpTileModule, [typeof TileComponent], [typeof i15.RouterModule, typeof i3$2.MatCardModule, typeof _angular_material_core.MatRippleModule, typeof i4.MatIconModule, typeof i9$2.MatDividerModule, typeof i4$1.CommonModule], [typeof TileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpTileModule>;
}

interface AppFeature {
    readonly route: string;
    readonly matIconName: string;
    readonly label: string;
    readonly description: string;
}

declare function areEqualByHashCode<T>(a: T, b: T): boolean;

declare function createOnChangeEffect$<TState, TObserved>(payload: {
    readonly store: Store<TState>;
    readonly observedSelector: Selector<TState, TObserved>;
}): rxjs.Observable<TObserved>;

declare const defaultRuntimeChecks: RuntimeChecks;

declare function distinctUntilHashChanged<T>(): rxjs.MonoTypeOperatorFunction<T>;
declare function distinctUntilDeepChanged<T>(): rxjs.MonoTypeOperatorFunction<T>;

declare abstract class DgpEffectsBase<TState> extends DgpContainer<TState> {
    protected createOnChangeEffect$<TObserved>(payload: {
        readonly observedSelector: Selector<TState, TObserved>;
    }): rxjs.Observable<TObserved>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpEffectsBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpEffectsBase<any>, never, never, {}, {}, never, never, true, never>;
}

declare function filterEmpty<T extends ReadonlyArray<TItem>, TItem>(): rxjs.MonoTypeOperatorFunction<T>;

declare function filterNotNullOrUndefined<T>(): rxjs.MonoTypeOperatorFunction<T>;

declare function flattenMatrix<T>(matrix: Matrix<T>): ReadonlyArray<T>;

declare function getHashCode(obj: any): number;

declare function negate(payload: any): boolean;

declare function negateMap<TModel>(): rxjs.OperatorFunction<TModel, boolean>;

declare abstract class DgpHybridComponentBase<TModel, TState> extends DgpModelEditorComponentBase<TModel> {
    protected readonly store: Store<TState>;
    constructor(store: Store<TState>);
    readonly select: <TV>(x: Selector<TState, TV>) => rxjs.Observable<TV>;
    readonly dispatch: (x: Action) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpHybridComponentBase<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpHybridComponentBase<any, any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * @deprecated This should not be used anymore. See DgpHybridComponentBase instead
 */
declare abstract class HybridComponentBase<TModel, TState, TData> extends DgpHybridComponentBase<TModel, TState> {
    readonly data$: rxjs.Observable<any>;
    abstract getData?(): Selector<TState, TData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HybridComponentBase<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HybridComponentBase<any, any, any>, never, never, {}, {}, never, never, true, never>;
}

declare class RxAttribute<TTarget extends object, TAttributeKey extends keyof TTarget> extends BehaviorSubject<TTarget[TAttributeKey]> {
}

declare function observeAttribute$<TTarget extends object, TAttributeKey extends keyof TTarget>(target: TTarget, attributeKey: TAttributeKey): rxjs.Observable<TTarget[TAttributeKey]>;

interface SelectEntityViaRouteResolverConfig<TEntityTypeMap extends EntityTypeMap, TStoreFeature = null> {
    readonly getNewEntitySurrogateKeyFromRoute: (route: ActivatedRouteSnapshot) => Promise<string>;
    readonly getOldEntitySurrogateKeyFromStore: () => Promise<string>;
    readonly entityName: keyof TEntityTypeMap;
    readonly storeFeature?: TStoreFeature;
}
declare abstract class DgpSelectEntityViaRouteResolver<TEntityTypeMap extends EntityTypeMap, TStoreFeature = null> {
    protected readonly store: Store<any>;
    private readonly config;
    protected constructor(store: Store<any>, config: SelectEntityViaRouteResolverConfig<TEntityTypeMap, TStoreFeature>);
    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<void>;
}

declare function isNullOrUndefined(value: any, ...additionalValues: any): boolean;
declare const nullOrUndefined: typeof isNullOrUndefined;
declare function notNullOrUndefined(value: any, ...additionalValues: any): boolean;

interface Point {
    readonly x: number;
    readonly y: number;
}

declare function resolveOverridableValue<TValue>(payload: {
    readonly computedValue: TValue;
    readonly overriddenValue?: TValue;
}): TValue;

declare abstract class DgpResolverBase<TState> extends DgpContainer<TState> {
    abstract resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpResolverBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DgpResolverBase<any>, never, never, {}, {}, never, never, true, never>;
}

declare function parseStringMatrixAsNumberMatrix(payload: Matrix<string>): Matrix<number>;

declare enum Magnitude {
    Femto,
    Piko,
    Nano,
    Mikro,
    Milli,
    None,
    Kilo,
    Mega,
    Giga,
    Tera,
    Peta
}

declare class HttpSSEApiClient {
    getStream$<T>(url: string, processor: (data: string) => T, eventSourceInitDict?: EventSourceInit): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpSSEApiClient, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpSSEApiClient>;
}

declare function firstAsPromise<T>(observable: Observable<T>): Promise<T>;

declare function there(payload: any): boolean;

declare function getDefaultValue<TModel extends object>(payload: ModelMetadata<TModel, any>): TModel;

/**
 * source: https://stackoverflow.com/questions/1960473/get-all-unique-values-in-a-javascript-array-remove-duplicates
 */
declare function byUnique<T>(value: T, index: number, self: T[]): boolean;

declare const matrixToMany: <T>(prev: T[], current: T[]) => T[];

declare function ofNull<T>(): rxjs.Observable<T>;

declare const withoutDispatch: EffectConfig & {
    functional?: false;
    dispatch: false;
};

declare function waitForStableDOM$(htmlNode: Node, config?: {
    stableTime: number;
}): Promise<void>;

declare class VirtualListItemDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualListItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualListItemDirective, "[dgpVirtualListItem]", never, {}, {}, never, never, false, never>;
}

declare class VirtualListPanelComponent implements AfterViewInit {
    private readonly elementRef;
    private readonly renderer;
    itemSize: number;
    items: ReadonlyArray<any>;
    itemTemplate: TemplateRef<any>;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualListPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualListPanelComponent, "dgp-virtual-list-panel", never, { "itemSize": { "alias": "itemSize"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, {}, ["itemTemplate"], never, false, never>;
}

declare class DgpVirtualListPanelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpVirtualListPanelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpVirtualListPanelModule, [typeof VirtualListPanelComponent, typeof VirtualListItemDirective], [typeof i4$1.CommonModule, typeof i4$4.ScrollingModule], [typeof VirtualListPanelComponent, typeof VirtualListItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpVirtualListPanelModule>;
}

interface DgpNgAppConfig<TAppState> {
    readonly appReducer: ActionReducerMap<TAppState>;
}
declare const APP_REDUCER: InjectionToken<ActionReducerMap<any, _ngrx_store.Action<string>>>;
declare class DgpNgAppModule {
    static forRoot<TAppState>(config: DgpNgAppConfig<TAppState>): ModuleWithProviders<DgpNgAppModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DgpNgAppModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DgpNgAppModule, never, [typeof i1.BrowserModule, typeof i2$4.BrowserAnimationsModule, typeof _ngrx_store.StoreRootModule, typeof i2.EffectsRootModule, typeof DgpHamburgerShellModule, typeof DgpThemeSwitcherModule, typeof DgpHamburgerMenuModule, typeof DgpLogModule, typeof DgpRequestStoreModule, typeof DgpRoutingOverlayModule], [typeof DgpHamburgerShellModule, typeof DgpThemeSwitcherModule, typeof DgpHamburgerMenuModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DgpNgAppModule>;
}

declare function selectFileItem(payload: FileItemId): entity_store.ComposedEntityActions<dgp_ng_app.FileUploadEntities, "FileUpload">;

export { APP_REDUCER, AuthenticationApiClient, AuthenticationGuard, AuthenticationService, AuthenticationServiceImpl, BROADCAST_CONFIG, BROADCAST_REDUCER, BroadcastRole, CompactThemeToggleComponent, DEFAULT_INSPECTOR_CONFIG, DarkModeToggleComponent, DgpActionContextDirective, DgpActionContextModule, DgpActionShortcutDirective, DgpAuthenticationModule, DgpBroadcastStoreModule, DgpCloseTableCellEditorDirective, DgpCompactThemeHostDirective, DgpConfirmDialogComponent, DgpConfirmDialogModule, DgpContainer, DgpDetailsComponent, DgpDetailsModule, DgpDialogMenuComponent, DgpDialogMenuModule, DgpDialogMenuService, DgpDialogMenuTriggerDirective, DgpDisabledBase, DgpDrawerLayoutComponent, DgpDrawerLayoutMenuToggleComponent, DgpEffectsBase, DgpEmptyStateModule, DgpExpansionToggleComponent, DgpExpansionToggleModule, DgpFileUploadModule, DgpFileViewerModule, DgpHamburgerMenuModule, DgpHamburgerMenuToggleModule, DgpHamburgerShellModule, DgpHybridComponentBase, DgpInputErrorInfoComponent, DgpInputFieldComponent, DgpInputFieldModule, DgpInputHintComponent, DgpInputLengthInfoComponent, DgpInputMetadataDirective, DgpInspectorConfigComponent, DgpInspectorConfigFormComponent, DgpInspectorConfigModule, DgpInspectorModule, DgpLazyRenderedComponent, DgpLazyRenderedContentDirective, DgpLazyRenderedModule, DgpLazyRenderedPlaceholderDirective, DgpListDetailsPageMenuToggleComponent, DgpListDetailsPageModule, DgpLogModule, DgpModelEditorComponentBase, DgpNegatePipe, DgpNegatePipeModule, DgpNgApp, DgpNgAppModule, DgpPageHeaderContextActionsComponent, DgpPageHeaderContextActionsModule, DgpPageHeaderModule, DgpRequestStoreModule, DgpResizeSensorDirective, DgpResizeSensorModule, DgpResolverBase, DgpRoutingOverlayModule, DgpSelectEntityViaRouteResolver, DgpShortcutModule, DgpSpacerModule, DgpTableCelLEditorDirective, DgpTableCellComponent, DgpTableCellEditorComponent, DgpTableCellEditorService, DgpTableCellModule, DgpThemeSwitcherModule, DgpTileModule, DgpView, DgpViewComponentBase, DgpVirtualListPanelModule, DragFileListenerDirective, DrawerLayoutMenuTogglePosition, DrawerMode, DynamicFileViewerComponent, EmptyStateComponent, FILE_UPLOAD_CONFIG, FILE_VIEWER_CONFIG, FallbackFileViewerComponent, FileItemListComponent, FileViewerComponent, FileViewerComponentBase, HAMBURGER_SHELL_CONFIG, HamburgerMenuComponent, HamburgerMenuEntriesComponent, HamburgerMenuEntryComponent, HamburgerMenuHeaderComponent, HamburgerMenuToggleComponent, HamburgerShellComponent, HamburgerShellMode, HttpSSEApiClient, HybridComponentBase, InitializationService, InspectorComponent, InspectorItemComponent, InspectorSectionComponent, InspectorService, JpgViewerComponent, ListDetailsPageComponent, ListDetailsPageContentComponent, ListDetailsPageMode, LogErrorAction, Magnitude, NoPeonGuard, OpenFileManagerViaShortKeyDirective, PageHeaderComponent, PdfViewerComponent, PngViewerComponent, ResizeSensor, RxAttribute, SHORTCUT_CONFIG, SafePipe, SafePipeModule, ScheduleRequestAction, SetBroadcastChannelDataIdAction, SetOwnBroadcastRoleAction, Severity, SpacerComponent, SvgViewerComponent, ThemeHostDirective, TileComponent, VirtualListItemDirective, VirtualListPanelComponent, actionBroadcastChannelId, actionContextFeatureSelector, actionContextReducer, actionContextStoreFeature, addFiles, addFilesViaDrop, addLogEntry, areEqualByHashCode, authenticateUser, authenticationReducer, authenticationServiceProvider, authenticationStoreFeature, broadcastReducer, broadcastReducerProvider, broadcastStoreFeature, broadcastStoreFeatureSelector, byUnique, canOpenFileDrawer, canSelectNextFile, canSelectPreviousFile, cancelButtonConfig, closeFileManager, closeHamburgerMenu, closeListDetailsMenu, confirmButtonConfig, createGuid, createOnChangeEffect$, defaultActionShortcutConfig, defaultBroadcastConfig, defaultBroadcastRoleDisplayConfig, defaultFileTypeViewerMap, defaultFileUploadConfig, defaultFileViewerConfig, defaultHamburgerShellConfig, defaultHamburgerShellConfigProvider, defaultResizeSensorConfig, defaultRuntimeChecks, defaultShortcutConfig, deselectActionContext, distinctUntilDeepChanged, distinctUntilHashChanged, downloadFile, emptyActionContext, emptyActionContextState, fileUploadEntityStore, fileUploadFeatureSelector, fileUploadStoreFeature, filterEmpty, filterNotNullOrUndefined, firstAsPromise, flattenMatrix, getAllDirectories, getAllFileItems, getAuthenticatedUser, getAuthenticatedUserSelector, getDefaultValue, getDirectoryState, getFileFromFileItem$, getFileFromUrl$, getFileItemKVS, getFileItemListModel, getFileItemSizeLabel, getFileItemState, getFileItemsFromFileList, getHashCode, getIsAuthenticatedSelector, getMimeTypeFromExtension, getOwnBroadcastRoleSelector, getSelectedActionContext, getSelectedActionContextKey, getSelectedActionContextLabel, getSelectedActionContextType, getSelectedActionContextValue, getSelectedFileItem, hamburgerMenuModeSelector, hamburgerShellFeatureSelector, hamburgerShellStoreFeature, hasMoreThanOneFile, hasPendingRequests, hasPendingRequestsSelector, heartbeatBroadcastChannelId, hideDropTarget, hmrReducer, hotReload, initialAuthenticationState, inspectorConfigMetadata, inspectorDefaultConfig, isActionContextSelected, isAddFilesDisabled, isAnyActionContextSelected, isAuthenticated, isCompactThemeActive, isDarkModeActive, isDarkModeActiveSelector, isDropTargetVisible, isFileManagerMenuDrawerOpen, isFileManagerOpen, isHamburgerMenuOpenSelector, isInitialized, isNullOrUndefined, isPageMenuOpenSelector, isRemoveFilesDisabled, logError, logErrorActionType, logStoreFeature, matrixToMany, negate, negateMap, notNullOrUndefined, nullOrUndefined, observeAttribute$, ofNull, openFileManager, openFileManagerOverlay, openFileManagerShortKeyFilter, overlayHamburgerShellConfig, overlayHamburgerShellConfigProvider, pageMenuModeSelector, parseCSVFile$, parseContentAsStringMatrix, parseFileNameWithExtension, parseStringMatrixAsNumberMatrix, provideDefaultInspectorConfig, provideShortcutConfig, removeFile, requestStateSelector, requestStoreFeature, resolveOverridableValue, responsiveHamburgerShellConfig, scheduleRequest, scheduleRequestActionType, selectActionContext, selectFileItem, selectNextFile, selectPreviousFile, setBroadcastChannelDataId, setConfig, setHamburgerMenuState, setIsDarkModeActive, setIsFileDrawerOpen, setListDetailsPageState, showDropTarget, showLoadingSpinner, sideNavHamburgerShellConfig, sideNavHamburgerShellConfigProvider, themeSwitcherFeatureSelector, themeSwitcherStoreFeature, there, toFileItemActionContext, toFileItemActionContextKey, toggleCompactTheme, toggleDarkMode, toggleHamburgerMenu, toggleListDetailsPageMenu, waitForStableDOM$, withoutDispatch };
export type { ActionContextState, ActionContextStoreFeature, ActionShortcut, ActionShortcutConfig, AppFeature, AuthenticationApiClientProvider, AuthenticationModuleSettings, AuthenticationState, BroadCastInitialStateRules, BroadcastAction, BroadcastChannelLike, BroadcastConfig, BroadcastHeartbeat, BroadcastInitialEntityStoreContentRule, BroadcastInitialStateActionRule, BroadcastInitialStateRule, BroadcastParticipant, BroadcastRoleDisplayConfig, BroadcastState, DataBroadcastChannel, Details, DgpNgAppConfig, Directory, DrawerLayout, ExpansionTogglePosition, FileItem, FileItemId, FileItemListModel, FileTypeViewerMap, FileUploadConfig, FileUploadEditingCapabilities, FileUploadEntities, FileUploadQueryParams, FileUploadState, FileUploadStoreFeature, FileViewerConfig, FirstArg, HamburgerMenuMode, HamburgerShellConfig, HamburgerShellConfigProvider, HamburgerShellState, InitializationServiceProvider, InspectorConfig, LogEntry, LogState, MessageEventLike, OpenFileManagerShortKeyFilter, PageMenuMode, Point, RemovalDialogButtonConfig, RequestState, ResizeSensorConfig, SelectEntityViaRouteResolverConfig, SendInitialStateSignature, ShortcutConfig, Size, ThemeSwitcherConfig, ThemeSwitcherState, TriggerEvent };