import * as i0 from '@angular/core';
import { OnChanges, OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, SimpleChanges, ElementRef, AfterViewInit, Renderer2, QueryList, InjectionToken, TemplateRef, ViewContainerRef, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
import * as i1 from '@angular/material/snack-bar';
import * as _angular_animations from '@angular/animations';
import { AnimationBuilder } from '@angular/animations';
import { BooleanInput } from '@angular/cdk/coercion';
import * as rxjs from 'rxjs';
import { Observable, ReplaySubject } from 'rxjs';
import { IsActiveMatchOptions, Params as Params$1, QueryParamsHandling, Router, ActivatedRoute } from '@angular/router';
import { GenesisLoadingService, IAppConfig, AuthService, UserModel, CoreService, TimeOnly, ApiClientConfig } from 'genesis-coreservice';
import { ScrollStrategyOptions, Overlay } from '@angular/cdk/overlay';
import { Platform } from '@angular/cdk/platform';
import PerfectScrollbar from 'perfect-scrollbar';
import { BreakpointObserver, BreakpointState } from '@angular/cdk/layout';
import { TranslocoService, LangDefinition, TranslocoLoader, Translation } from '@jsverse/transloco';
import { HttpClient } from '@angular/common/http';
import { UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
import { Notification, PushNotificationType, NotificationEvent } from 'genesis-apiservices';
import { MatIconRegistry } from '@angular/material/icon';
import * as _angular_platform_browser from '@angular/platform-browser';
import { DomSanitizer } from '@angular/platform-browser';

declare class ServiceModule {
    constructor(parentModule: ServiceModule);
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceModule, [{ optional: true; skipSelf: true; }]>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ServiceModule, never, [typeof i1.MatSnackBarModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ServiceModule>;
}

declare const genesisAnimations: _angular_animations.AnimationTriggerMetadata[];

declare class GenesisAlertService {
    private readonly _onDismiss;
    private readonly _onShow;
    /**
     * Constructor
     */
    constructor();
    /**
     * Getter for onDismiss
     */
    get onDismiss(): Observable<any>;
    /**
     * Getter for onShow
     */
    get onShow(): Observable<any>;
    /**
     * Dismiss the alert
     *
     * @param name
     */
    dismiss(name: string): void;
    /**
     * Show the dismissed alert
     *
     * @param name
     */
    show(name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisAlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisAlertService>;
}

type GenesisAlertAppearance = 'border' | 'fill' | 'outline' | 'soft';
type GenesisAlertType = 'primary' | 'accent' | 'warn' | 'basic' | 'info' | 'success' | 'warning' | 'error';

declare class GenesisUtilsService {
    /**
     * Constructor
     */
    constructor();
    /**
     * Get the equivalent "IsActiveMatchOptions" options for "exact = true".
     */
    get exactMatchOptions(): IsActiveMatchOptions;
    /**
     * Get the equivalent "IsActiveMatchOptions" options for "exact = false".
     */
    get subsetMatchOptions(): IsActiveMatchOptions;
    /**
     * Generates a random id
     *
     * @param length
     */
    randomId(length?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisUtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisUtilsService>;
}

declare class GenesisAlertComponent implements OnChanges, OnInit, OnDestroy {
    private _changeDetectorRef;
    private _genesisAlertService;
    private _genesisUtilsService;
    static ngAcceptInputType_dismissible: BooleanInput;
    static ngAcceptInputType_dismissed: BooleanInput;
    static ngAcceptInputType_showIcon: BooleanInput;
    appearance: GenesisAlertAppearance;
    dismissed: boolean;
    dismissible: boolean;
    name: string;
    showIcon: boolean;
    type: GenesisAlertType;
    readonly dismissedChanged: EventEmitter<boolean>;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(_changeDetectorRef: ChangeDetectorRef, _genesisAlertService: GenesisAlertService, _genesisUtilsService: GenesisUtilsService);
    /**
     * Host binding for component classes
     */
    get classList(): any;
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    /**
     * Dismiss the alert
     */
    dismiss(): void;
    /**
     * Show the dismissed alert
     */
    show(): void;
    /**
     * Dismiss/show the alert
     *
     * @param dismissed
     * @private
     */
    private _toggleDismiss;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisAlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisAlertComponent, "genesis-alert", ["genesisAlert"], { "appearance": { "alias": "appearance"; "required": false; }; "dismissed": { "alias": "dismissed"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "dismissedChanged": "dismissedChanged"; }, never, ["[genesisAlertIcon]", "[genesisAlertTitle]", "*"], true, never>;
}

type GenesisCardFace = 'front' | 'back';

declare class GenesisCardComponent implements OnChanges {
    static ngAcceptInputType_expanded: BooleanInput;
    static ngAcceptInputType_flippable: BooleanInput;
    expanded: boolean;
    face: GenesisCardFace;
    flippable: boolean;
    /**
     * Constructor
     */
    constructor();
    /**
     * Host binding for component classes
     */
    get classList(): any;
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisCardComponent, "genesis-card", ["genesisCard"], { "expanded": { "alias": "expanded"; "required": false; }; "face": { "alias": "face"; "required": false; }; "flippable": { "alias": "flippable"; "required": false; }; }, {}, never, ["[genesisCardFront]", "[genesisCardBack]", "*", "[genesisCardExpansion]"], true, never>;
}

declare class GenesisLoadingBarComponent implements OnChanges, OnInit, OnDestroy {
    private genesisLoadingService;
    autoMode: boolean;
    mode: 'determinate' | 'indeterminate';
    progress: number;
    show: boolean;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(genesisLoadingService: GenesisLoadingService);
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisLoadingBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisLoadingBarComponent, "genesis-loading-bar", ["genesisLoadingBar"], { "autoMode": { "alias": "autoMode"; "required": false; }; }, {}, never, never, true, never>;
}

interface GenesisNavigationItem {
    id?: string;
    title?: string;
    subtitle?: string;
    type: 'aside' | 'basic' | 'collapsable' | 'divider' | 'group' | 'spacer';
    hidden?: (item: GenesisNavigationItem) => boolean;
    active?: boolean;
    disabled?: boolean;
    tooltip?: string;
    link?: string;
    fragment?: string;
    preserveFragment?: boolean;
    queryParams?: Params$1 | null;
    queryParamsHandling?: QueryParamsHandling | null;
    externalLink?: boolean;
    target?: '_blank' | '_self' | '_parent' | '_top' | string;
    exactMatch?: boolean;
    isActiveMatchOptions?: IsActiveMatchOptions;
    function?: (item: GenesisNavigationItem) => void;
    classes?: {
        title?: string;
        subtitle?: string;
        icon?: string;
        wrapper?: string;
    };
    icon?: string;
    badge?: {
        title?: string;
        classes?: string;
    };
    children?: GenesisNavigationItem[];
    meta?: any;
    translationKey?: string;
}
type GenesisVerticalNavigationAppearance = 'default' | 'compact' | 'dense' | 'thin';
type GenesisVerticalNavigationMode = 'over' | 'side';
type GenesisVerticalNavigationPosition = 'left' | 'right';

declare class ScrollbarGeometry {
    x: number;
    y: number;
    w: number;
    h: number;
    constructor(x: number, y: number, w: number, h: number);
}
declare class ScrollbarPosition {
    x: number | 'start' | 'end';
    y: number | 'start' | 'end';
    constructor(x: number | 'start' | 'end', y: number | 'start' | 'end');
}

/**
 * Wrapper directive for the Perfect Scrollbar: https://github.com/mdbootstrap/perfect-scrollbar
 */
declare class GenesisScrollbarDirective implements OnChanges, OnInit, OnDestroy {
    private _elementRef;
    private _platform;
    private _router;
    static ngAcceptInputType_genesisScrollbar: BooleanInput;
    genesisScrollbar: boolean;
    genesisScrollbarOptions: PerfectScrollbar.Options;
    private _animation?;
    private _options;
    private _ps?;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(_elementRef: ElementRef, _platform: Platform, _router: Router);
    /**
     * Getter for _elementRef
     */
    get elementRef(): ElementRef;
    /**
     * Getter for _ps
     */
    get ps(): PerfectScrollbar | null | undefined;
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    /**
     * Is enabled
     */
    isEnabled(): boolean;
    /**
     * Update the scrollbar
     */
    update(): void;
    /**
     * Destroy the scrollbar
     */
    destroy(): void;
    /**
     * Returns the geometry of the scrollable element
     *
     * @param prefix
     */
    geometry(prefix?: string): ScrollbarGeometry;
    /**
     * Returns the position of the scrollable element
     *
     * @param absolute
     */
    position(absolute?: boolean): ScrollbarPosition;
    /**
     * Scroll to
     *
     * @param x
     * @param y
     * @param speed
     */
    scrollTo(x: number, y?: number, speed?: number): void;
    /**
     * Scroll to X
     *
     * @param x
     * @param speed
     */
    scrollToX(x: number, speed?: number): void;
    /**
     * Scroll to Y
     *
     * @param y
     * @param speed
     */
    scrollToY(y: number, speed?: number): void;
    /**
     * Scroll to top
     *
     * @param offset
     * @param speed
     */
    scrollToTop(offset?: number, speed?: number): void;
    /**
     * Scroll to bottom
     *
     * @param offset
     * @param speed
     */
    scrollToBottom(offset?: number, speed?: number): void;
    /**
     * Scroll to left
     *
     * @param offset
     * @param speed
     */
    scrollToLeft(offset?: number, speed?: number): void;
    /**
     * Scroll to right
     *
     * @param offset
     * @param speed
     */
    scrollToRight(offset?: number, speed?: number): void;
    /**
     * Scroll to element
     *
     * @param qs
     * @param offset
     * @param ignoreVisible If true, scrollToElement won't happen if element is already inside the current viewport
     * @param speed
     */
    scrollToElement(qs: string, offset?: number, ignoreVisible?: boolean, speed?: number): void;
    /**
     * Animate scrolling
     *
     * @param target
     * @param value
     * @param speed
     */
    animateScrolling(target: string, value: number, speed?: number): void;
    /**
     * Initialize
     *
     * @private
     */
    private _init;
    /**
     * Destroy
     *
     * @private
     */
    private _destroy;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisScrollbarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GenesisScrollbarDirective, "[genesisScrollbar]", ["genesisScrollbar"], { "genesisScrollbar": { "alias": "genesisScrollbar"; "required": false; }; "genesisScrollbarOptions": { "alias": "genesisScrollbarOptions"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GenesisNavigationService {
    private _componentRegistry;
    private _navigationStore;
    /**
     * Constructor
     */
    constructor();
    /**
     * Register navigation component
     *
     * @param name
     * @param component
     */
    registerComponent(name: string, component: any): void;
    /**
     * Deregister navigation component
     *
     * @param name
     */
    deregisterComponent(name: string): void;
    /**
     * Get navigation component from the registry
     *
     * @param name
     */
    getComponent<T>(name: string): T;
    /**
     * Store the given navigation with the given key
     *
     * @param key
     * @param navigation
     */
    storeNavigation(key: string, navigation: GenesisNavigationItem[]): void;
    /**
     * Get navigation from storage by key
     *
     * @param key
     */
    getNavigation(key: string): GenesisNavigationItem[];
    /**
     * Delete the navigation from the storage
     *
     * @param key
     */
    deleteNavigation(key: string): void;
    /**
     * Utility function that returns a flattened
     * version of the given navigation array
     *
     * @param navigation
     * @param flatNavigation
     */
    getFlatNavigation(navigation: GenesisNavigationItem[], flatNavigation?: GenesisNavigationItem[]): GenesisNavigationItem[];
    /**
     * Utility function that returns the item
     * with the given id from given navigation
     *
     * @param id
     * @param navigation
     */
    getItem(id: string, navigation: GenesisNavigationItem[]): GenesisNavigationItem | null;
    /**
     * Utility function that returns the item's parent
     * with the given id from given navigation
     *
     * @param id
     * @param navigation
     * @param parent
     */
    getItemParent(id: string, navigation: GenesisNavigationItem[], parent: GenesisNavigationItem[] | GenesisNavigationItem): GenesisNavigationItem[] | GenesisNavigationItem | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisNavigationService>;
}

declare class GenesisVerticalNavigationComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {
    private _animationBuilder;
    private _changeDetectorRef;
    private _document;
    private _elementRef;
    private _renderer2;
    private _router;
    private _scrollStrategyOptions;
    private _genesisNavigationService;
    private _genesisUtilsService;
    static ngAcceptInputType_inner: BooleanInput;
    static ngAcceptInputType_opened: BooleanInput;
    static ngAcceptInputType_transparentOverlay: BooleanInput;
    appearance: GenesisVerticalNavigationAppearance;
    autoCollapse: boolean;
    inner: boolean;
    mode: GenesisVerticalNavigationMode;
    name: string;
    navigation: GenesisNavigationItem[];
    opened: boolean;
    position: GenesisVerticalNavigationPosition;
    transparentOverlay: boolean;
    readonly appearanceChanged: EventEmitter<GenesisVerticalNavigationAppearance>;
    readonly modeChanged: EventEmitter<GenesisVerticalNavigationMode>;
    readonly openedChanged: EventEmitter<boolean>;
    readonly positionChanged: EventEmitter<GenesisVerticalNavigationPosition>;
    private _navigationContentEl;
    activeAsideItemId: string | null;
    onCollapsableItemCollapsed: ReplaySubject<GenesisNavigationItem>;
    onCollapsableItemExpanded: ReplaySubject<GenesisNavigationItem>;
    onRefreshed: ReplaySubject<boolean>;
    private _animationsEnabled;
    private _asideOverlay?;
    private readonly _handleAsideOverlayClick;
    private readonly _handleOverlayClick;
    private _hovered;
    private _mutationObserver;
    private _overlay?;
    private _player;
    private _scrollStrategy;
    private _genesisScrollbarDirectives;
    private _genesisScrollbarDirectivesSubscription;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(_animationBuilder: AnimationBuilder, _changeDetectorRef: ChangeDetectorRef, _document: Document, _elementRef: ElementRef, _renderer2: Renderer2, _router: Router, _scrollStrategyOptions: ScrollStrategyOptions, _genesisNavigationService: GenesisNavigationService, _genesisUtilsService: GenesisUtilsService);
    /**
     * Host binding for component classes
     */
    get classList(): any;
    /**
     * Host binding for component inline styles
     */
    get styleList(): any;
    /**
     * Setter for genesisScrollbarDirectives
     */
    set genesisScrollbarDirectives(genesisScrollbarDirectives: QueryList<GenesisScrollbarDirective>);
    /**
     * On mouseenter
     *
     * @public
     */
    onMouseenter(): void;
    /**
     * On mouseleave
     *
     * @public
     */
    onMouseleave(): void;
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * After view init
     */
    ngAfterViewInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    /**
     * Refresh the component to apply the changes
     */
    refresh(): void;
    /**
     * Open the navigation
     */
    open(): void;
    /**
     * Close the navigation
     */
    close(): void;
    /**
     * Toggle the navigation
     */
    toggle(): void;
    /**
     * Open the aside
     *
     * @param item
     */
    openAside(item: GenesisNavigationItem): void;
    /**
     * Close the aside
     */
    closeAside(): void;
    /**
     * Toggle the aside
     *
     * @param item
     */
    toggleAside(item: GenesisNavigationItem): void;
    /**
     * Track by function for ngFor loops
     *
     * @param index
     * @param item
     */
    trackByFn(index: number, item: any): any;
    /**
     * Enable the animations
     *
     * @private
     */
    private _enableAnimations;
    /**
     * Disable the animations
     *
     * @private
     */
    private _disableAnimations;
    /**
     * Show the overlay
     *
     * @private
     */
    private _showOverlay;
    /**
     * Hide the overlay
     *
     * @private
     */
    private _hideOverlay;
    /**
     * Show the aside overlay
     *
     * @private
     */
    private _showAsideOverlay;
    /**
     * Hide the aside overlay
     *
     * @private
     */
    private _hideAsideOverlay;
    /**
     * Open/close the navigation
     *
     * @param open
     * @private
     */
    private _toggleOpened;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisVerticalNavigationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisVerticalNavigationComponent, "genesis-vertical-navigation", ["genesisVerticalNavigation"], { "appearance": { "alias": "appearance"; "required": false; }; "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "inner": { "alias": "inner"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "name": { "alias": "name"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; }, { "appearanceChanged": "appearanceChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; }, never, ["[genesisVerticalNavigationHeader]", "[genesisVerticalNavigationContentHeader]", "[genesisVerticalNavigationContentFooter]", "[genesisVerticalNavigationFooter]"], true, never>;
}

declare class GenesisHorizontalNavigationComponent implements OnChanges, OnInit, OnDestroy {
    private changeDetectorRef;
    private genesisNavigationService;
    private genesisUtilsService;
    name: string;
    readonly navigation: i0.InputSignal<GenesisNavigationItem[]>;
    onRefreshed: ReplaySubject<boolean>;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(changeDetectorRef: ChangeDetectorRef, genesisNavigationService: GenesisNavigationService, genesisUtilsService: GenesisUtilsService);
    /**
     * On changes
     *
     * @param changes
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    /**
     * Refresh the component to apply the changes
     */
    refresh(): void;
    /**
     * Track by function for ngFor loops
     *
     * @param index
     * @param item
     */
    trackByFn(index: number, item: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisHorizontalNavigationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisHorizontalNavigationComponent, "genesis-horizontal-navigation", ["genesisHorizontalNavigation"], { "name": { "alias": "name"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GenesisConfigService {
    private _config;
    /**
     * Constructor
     */
    constructor(config: any);
    /**
     * Setter & getter for config
     */
    set config(value: any);
    get config$(): Observable<any>;
    /**
     * Resets the config to the default
     */
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisConfigService>;
}

declare class GenesisMediaWatcherService {
    private _breakpointObserver;
    private _genesisConfigService;
    private _onMediaChange;
    /**
     * Constructor
     */
    constructor(_breakpointObserver: BreakpointObserver, _genesisConfigService: GenesisConfigService);
    /**
     * Getter for _onMediaChange
     */
    get onMediaChange$(): Observable<{
        matchingAliases: string[];
        matchingQueries: any;
    }>;
    /**
     * On media query change
     *
     * @param query
     */
    onMediaQueryChange$(query: string | string[]): Observable<BreakpointState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisMediaWatcherService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisMediaWatcherService>;
}

interface BreadcrumbsModel {
    title: string;
    link?: string;
    queryParams?: any;
}

declare class GenesisChildSidebarComponent implements OnInit, OnDestroy {
    private genesisMediaWatcherService;
    PageTitle: string;
    ShowPageTitle: boolean;
    SidebarTitle: string;
    ShowSidebarTitle: boolean;
    Breadcrumbs: Array<BreadcrumbsModel>;
    MenuData: GenesisNavigationItem[];
    IsBgWhite: boolean;
    IsDefaultPadding: boolean;
    HideDrawer: boolean;
    drawerMode: 'over' | 'side';
    drawerOpened: boolean;
    private unsubscribeAll;
    constructor(genesisMediaWatcherService: GenesisMediaWatcherService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisChildSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisChildSidebarComponent, "genesis-child-sidebar", never, { "PageTitle": { "alias": "PageTitle"; "required": false; }; "ShowPageTitle": { "alias": "ShowPageTitle"; "required": false; }; "SidebarTitle": { "alias": "SidebarTitle"; "required": false; }; "ShowSidebarTitle": { "alias": "ShowSidebarTitle"; "required": false; }; "Breadcrumbs": { "alias": "Breadcrumbs"; "required": false; }; "MenuData": { "alias": "MenuData"; "required": false; }; "IsBgWhite": { "alias": "IsBgWhite"; "required": false; }; "IsDefaultPadding": { "alias": "IsDefaultPadding"; "required": false; }; "HideDrawer": { "alias": "HideDrawer"; "required": false; }; }, {}, never, ["[childTopContent]", "[childBottomContent]"], true, never>;
}

declare class GenesisBreadcrumbsComponent implements OnInit {
    Breadcrumbs: Array<BreadcrumbsModel>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisBreadcrumbsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisBreadcrumbsComponent, "genesis-breadcrumbs", never, { "Breadcrumbs": { "alias": "Breadcrumbs"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BreadcrumbService {
    private router;
    private route;
    private translocoService;
    private breadcrumbsSubject;
    breadcrumbs$: rxjs.Observable<any[]>;
    constructor(router: Router, route: ActivatedRoute, translocoService: TranslocoService);
    private buildBreadcrumbs;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
}

declare class BreadcrumbComponent implements OnInit {
    private breadcrumbService;
    breadcrumbs: any[];
    constructor(breadcrumbService: BreadcrumbService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "lib-breadcrumb", never, {}, {}, never, never, true, never>;
}

declare class ChildSidebarComponent {
    MenuData: GenesisNavigationItem[];
    SidebarTitle: string;
    ShowSidebarTitle: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChildSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChildSidebarComponent, "child-sidebar", never, { "MenuData": { "alias": "MenuData"; "required": false; }; "SidebarTitle": { "alias": "SidebarTitle"; "required": false; }; "ShowSidebarTitle": { "alias": "ShowSidebarTitle"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GenesisDrawerComponent {
    Breadcrumbs: Array<BreadcrumbsModel>;
    IsBgWhite: boolean;
    IsDefaultPadding: boolean;
    useNewBreadcrumb: boolean;
    drawerOpened: boolean;
    drawerMode: 'over' | 'side';
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisDrawerComponent, "genesis-drawer", never, { "Breadcrumbs": { "alias": "Breadcrumbs"; "required": false; }; "IsBgWhite": { "alias": "IsBgWhite"; "required": false; }; "IsDefaultPadding": { "alias": "IsDefaultPadding"; "required": false; }; "useNewBreadcrumb": { "alias": "useNewBreadcrumb"; "required": false; }; "drawerOpened": { "alias": "drawerOpened"; "required": false; }; "drawerMode": { "alias": "drawerMode"; "required": false; }; }, {}, never, ["[drawerContent]", "[mainContent]"], true, never>;
}

declare class GenesisScrollResetDirective implements OnInit, OnDestroy {
    private _elementRef;
    private _router;
    private _unsubscribeAll;
    /**
     * Constructor
     */
    constructor(_elementRef: ElementRef, _router: Router);
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisScrollResetDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GenesisScrollResetDirective, "[genesisScrollReset]", ["genesisScrollReset"], {}, {}, never, never, true, never>;
}

declare const GENESIS_CONFIG: InjectionToken<any>;

type Scheme = 'auto' | 'dark' | 'light';
type Screens = {
    [key: string]: string;
};
type Theme = 'theme-default' | string;
type Themes = {
    id: string;
    name: string;
}[];
/**
 * AppConfig interface. Update this interface to strictly type your config
 * object.
 */
interface GenesisConfig {
    layout: string;
    scheme: Scheme;
    screens: Screens;
    theme: Theme;
    themes: Themes;
}

declare class GenesisPlatformService {
    private _platform;
    osName: string;
    /**
     * Constructor
     */
    constructor(_platform: Platform);
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisPlatformService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisPlatformService>;
}

declare class GenesisSplashScreenService {
    private _document;
    private _router;
    /**
     * Constructor
     */
    constructor(_document: any, _router: Router);
    /**
     * Show the splash screen
     */
    show(): void;
    /**
     * Hide the splash screen
     */
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisSplashScreenService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenesisSplashScreenService>;
}

declare const GENESIS_VERSION: string;

/**
 * Derived from Angular's version class
 */
declare class Version {
    version: string;
    readonly full: string;
    readonly major: string;
    readonly minor: string;
    readonly patch: string;
    /**
     * Constructor
     */
    constructor(version: string);
}

declare class GenesisFullscreenComponent implements OnInit {
    private _document;
    iconTpl: TemplateRef<any>;
    tooltip: string;
    targetElement: HTMLElement;
    private _fsDoc;
    private _fsDocEl;
    private _isFullscreen;
    /**
     * Constructor
     */
    constructor(_document: Document);
    /**
     * On init
     */
    ngOnInit(): void;
    /**
     * Toggle the fullscreen mode
     */
    toggleFullscreen(): void;
    /**
     * Get browser's fullscreen element
     *
     * @private
     */
    private _getBrowserFullscreenElement;
    /**
     * Open the fullscreen
     *
     * @private
     */
    private _openFullscreen;
    /**
     * Close the fullscreen
     *
     * @private
     */
    private _closeFullscreen;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisFullscreenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisFullscreenComponent, "genesis-fullscreen", ["genesisFullscreen"], { "iconTpl": { "alias": "iconTpl"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "targetElement": { "alias": "targetElement"; "required": false; }; }, {}, never, never, true, never>;
}

interface FSDocument extends HTMLDocument {
    mozFullScreenElement?: Element;
    mozCancelFullScreen?: () => void;
    msFullscreenElement?: Element;
    msExitFullscreen?: () => void;
    webkitFullscreenElement?: Element;
    webkitExitFullscreen?: () => void;
}
interface FSDocumentElement extends HTMLElement {
    mozRequestFullScreen?: () => void;
    msRequestFullscreen?: () => void;
    webkitRequestFullscreen?: () => void;
}

declare class CallbackComponent implements OnInit {
    private authService;
    appConfig: IAppConfig;
    logo: string;
    constructor(authService: AuthService, appConfig: IAppConfig);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CallbackComponent, "app-callback", never, {}, {}, never, never, true, never>;
}

declare class LoginComponent implements OnInit {
    appConfig: IAppConfig;
    private authService;
    clock: string;
    logo: string;
    constructor(appConfig: IAppConfig, authService: AuthService);
    ngOnInit(): void;
    login(): void;
    startTime: () => void;
    checkTime: (i: number) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "app-login", never, {}, {}, never, never, true, never>;
}

declare class LogoutComponent implements OnInit {
    appConfig: IAppConfig;
    private authService;
    clock: string;
    logo: string;
    constructor(appConfig: IAppConfig, authService: AuthService);
    ngOnInit(): void;
    login(): void;
    startTime: () => void;
    checkTime: (i: number) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogoutComponent, "app-logout", never, {}, {}, never, never, true, never>;
}

interface Navigation {
    compact: GenesisNavigationItem[];
    default: GenesisNavigationItem[];
    futuristic: GenesisNavigationItem[];
    horizontal: GenesisNavigationItem[];
}

interface IApps {
    id: string;
    label: string;
    description?: string;
    icon: string;
    link: string;
    useRouter: boolean;
}

declare class AppsService {
    private _apps;
    get apps$(): Observable<IApps[]>;
    set apps$(value: IApps[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<AppsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppsService>;
}

declare class NavigationService {
    private _httpClient;
    private _navigation;
    constructor(_httpClient: HttpClient);
    set navigation$(notification: Navigation);
    get navigation$(): Observable<Navigation>;
    get(): Observable<Navigation>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
}

declare class ClassyLayoutComponent implements OnInit, OnDestroy {
    private readonly navigationService;
    private readonly authService;
    private readonly genesisMediaWatcherService;
    private readonly genesisNavigationService;
    private readonly appsService;
    private readonly configService;
    appConfig: IAppConfig;
    isScreenSmall: boolean;
    isAppsPanel: boolean;
    navigation: Navigation;
    user: UserModel;
    config?: GenesisConfig;
    private readonly unsubscribeAll;
    constructor(navigationService: NavigationService, authService: AuthService, genesisMediaWatcherService: GenesisMediaWatcherService, genesisNavigationService: GenesisNavigationService, appsService: AppsService, configService: GenesisConfigService, appConfig: IAppConfig);
    get currentYear(): number;
    ngOnInit(): void;
    ngOnDestroy(): void;
    toggleNavigation(name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClassyLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ClassyLayoutComponent, "classy-layout", never, {}, {}, never, never, true, never>;
}

interface InvitationModel {
    emails: string[];
}

declare class InvitationService {
    private _pushInvitation;
    get getInvitation$(): Observable<InvitationModel>;
    set setInvitation$(invitation: InvitationModel);
    static ɵfac: i0.ɵɵFactoryDeclaration<InvitationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InvitationService>;
}

declare class InvitationComponent implements OnInit, OnDestroy {
    private invitationService;
    private _overlay;
    private _viewContainerRef;
    private _invitationOrigin;
    private _invitationPanel;
    buttonText: string;
    title: string;
    shortcutForm: UntypedFormGroup;
    model: InvitationModel;
    invitationToolbars: any[];
    private _overlayRef;
    private _unsubscribeAll;
    constructor(invitationService: InvitationService, _overlay: Overlay, _viewContainerRef: ViewContainerRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    openPanel(): void;
    closePanel(): void;
    save(): void;
    private _createOverlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvitationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InvitationComponent, "invitation", ["invitation"], { "buttonText": { "alias": "buttonText"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ApplicationsComponent implements OnInit, OnDestroy {
    private _changeDetectorRef;
    private _appsService;
    private _overlay;
    private _viewContainerRef;
    private _appsOrigin;
    private _appsPanel;
    apps: IApps[];
    private _overlayRef;
    private _unsubscribeAll;
    constructor(_changeDetectorRef: ChangeDetectorRef, _appsService: AppsService, _overlay: Overlay, _viewContainerRef: ViewContainerRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    openPanel(): void;
    closePanel(): void;
    trackByFn(index: number, item: any): any;
    private _createOverlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationsComponent, "applications", ["applications"], {}, {}, never, never, true, never>;
}

declare class LanguagesComponent implements OnInit {
    private readonly genesisNavigationService;
    private readonly translocoService;
    private readonly coreService;
    availableLangs: LangDefinition[];
    activeLang: string;
    flagCodes: Record<string, string>;
    constructor(genesisNavigationService: GenesisNavigationService, translocoService: TranslocoService, coreService: CoreService);
    ngOnInit(): void;
    setActiveLang(lang: string): Promise<void>;
    trackByFn(index: number, item: any): any;
    private updateNavigation;
    private getLanguageLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguagesComponent, "languages", ["languages"], {}, {}, never, never, true, never>;
}
interface ILanguageDropdownItem {
    key: string;
    value: string;
    icon?: string;
}

declare class NotificationsComponent implements OnInit, OnDestroy {
    private changeDetectorRef;
    private notificationEvent;
    private overlay;
    private viewContainerRef;
    appConfig: IAppConfig;
    private notificationsOrigin?;
    private notificationsPanel?;
    notifications: Notification[];
    unreadCount: number;
    notificationType: PushNotificationType;
    private overlayRef?;
    private unsubscribeAll;
    constructor(changeDetectorRef: ChangeDetectorRef, notificationEvent: NotificationEvent, overlay: Overlay, viewContainerRef: ViewContainerRef, appConfig: IAppConfig);
    ngOnInit(): void;
    ngOnDestroy(): void;
    openPanel(): void;
    closePanel(): void;
    markAllAsRead(): void;
    toggleRead(notification: Notification): void;
    deleteNotify(notification: Notification): void;
    trackByFn(index: number, item: any): any;
    Acceptation(notification: Notification): void;
    reject(notification: Notification): void;
    private createOverlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationsComponent, "notifications", ["notifications"], {}, {}, never, never, true, never>;
}

interface Shortcut {
    id: string;
    label: string;
    description?: string;
    icon: string;
    link: string;
    useRouter: boolean;
}

declare class ShortcutsService {
    private _httpClient;
    private _shortcuts;
    constructor(_httpClient: HttpClient);
    get shortcuts$(): Observable<Shortcut[]>;
    getAll(): Observable<Shortcut[]>;
    create(shortcut: Shortcut): Observable<Shortcut>;
    update(id: string, shortcut: Shortcut): Observable<Shortcut>;
    delete(id: string): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortcutsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ShortcutsService>;
}

declare class ShortcutsComponent implements OnInit, OnDestroy {
    private _changeDetectorRef;
    private _formBuilder;
    private _shortcutsService;
    private _overlay;
    private _viewContainerRef;
    private _shortcutsOrigin;
    private _shortcutsPanel;
    mode: 'view' | 'modify' | 'add' | 'edit';
    shortcutForm: UntypedFormGroup;
    shortcuts: Shortcut[];
    private _overlayRef;
    private _unsubscribeAll;
    constructor(_changeDetectorRef: ChangeDetectorRef, _formBuilder: UntypedFormBuilder, _shortcutsService: ShortcutsService, _overlay: Overlay, _viewContainerRef: ViewContainerRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    openPanel(): void;
    closePanel(): void;
    changeMode(mode: 'view' | 'modify' | 'add' | 'edit'): void;
    newShortcut(): void;
    editShortcut(shortcut: Shortcut): void;
    save(): void;
    delete(): void;
    trackByFn(index: number, item: any): any;
    private _createOverlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortcutsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShortcutsComponent, "shortcuts", ["shortcuts"], {}, {}, never, never, true, never>;
}

declare class UserComponent implements OnInit, OnDestroy {
    private _changeDetectorRef;
    appConfig: IAppConfig;
    private _authService;
    static ngAcceptInputType_showAvatar: BooleanInput;
    showAvatar: boolean;
    user: UserModel;
    private _unsubscribeAll;
    constructor(_changeDetectorRef: ChangeDetectorRef, appConfig: IAppConfig, _authService: AuthService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    updateUserStatus(status: string): void;
    signOut(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserComponent, "user", ["user"], { "showAvatar": { "alias": "showAvatar"; "required": false; }; }, {}, never, never, true, never>;
}

interface ChatTransfer {
    sessionId: string;
    commandText: string;
}
interface ChatResponse {
    isComplete?: boolean;
    message: string;
    question?: string;
    role: 'user' | 'agent';
    data?: any;
    createdAt: Date;
}
interface ChatTransferAi {
    inputText: string;
}

declare class ChatAgentService extends CoreService {
    ChatTransfer(request: ChatTransfer): Promise<ChatResponse>;
    Chat(request: FormData): Promise<ChatResponse>;
    ChatTransferAi(request: ChatTransferAi): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChatAgentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChatAgentService>;
}

declare class GenesisChatAgentComponent implements OnInit {
    private readonly chatAgentService;
    private readonly _document;
    private readonly _renderer2;
    private matIconRegistry;
    private domSanitizer;
    postModel: ChatTransfer;
    isPanelOpened: boolean;
    agentSteps: string[];
    isRecording: boolean;
    recordedAudio?: Blob;
    recordedAudioUrl: string;
    recordSeconds: number;
    chatHistory: ChatResponse[];
    data: any;
    file?: File;
    private _overlay;
    private mediaRecorder?;
    private audioChunks;
    private recordTimer?;
    constructor(chatAgentService: ChatAgentService, _document: Document, _renderer2: Renderer2, matIconRegistry: MatIconRegistry, domSanitizer: DomSanitizer);
    ngOnInit(): void;
    togglePanel(): void;
    sendMessage(): void;
    recordVoice(): void;
    stopRecording(): void;
    sendRecordedAudio(): void;
    discardRecordedAudio(): void;
    attachFile(): void;
    resizeTextarea(event: Event): void;
    private startRecordTimer;
    private stopRecordTimer;
    get recordTime(): string;
    private _getContentContainer;
    private _showOverlay;
    private _hideOverlay;
    get fileExtension(): string;
    private mimeToExt;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenesisChatAgentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenesisChatAgentComponent, "genesis-chat-agent", never, {}, {}, never, never, true, never>;
}

declare class ThemeSwitchComponent implements OnInit, OnDestroy {
    private readonly configService;
    config?: GenesisConfig;
    private unsubscribeAll;
    constructor(configService: GenesisConfigService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    setScheme(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThemeSwitchComponent, "theme-switch", ["theme-switch"], {}, {}, never, never, true, never>;
}

declare class LayoutComponent implements OnInit, OnDestroy {
    private activatedRoute;
    private _document;
    private renderer2;
    private router;
    private genesisConfigService;
    private genesisMediaWatcherService;
    private genesisPlatformService;
    config: GenesisConfig;
    layout: string;
    scheme: 'dark' | 'light';
    theme: string;
    private unsubscribeAll;
    /**
     * Constructor
     */
    constructor(activatedRoute: ActivatedRoute, _document: any, renderer2: Renderer2, router: Router, genesisConfigService: GenesisConfigService, genesisMediaWatcherService: GenesisMediaWatcherService, genesisPlatformService: GenesisPlatformService);
    ngOnInit(): void;
    /**
     * On destroy
     */
    ngOnDestroy(): void;
    private _updateLayout;
    /**
     * Update the selected scheme
     *
     * @private
     */
    private _updateScheme;
    private _updateTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutComponent, "layout", never, {}, {}, never, never, true, never>;
}

interface IResponse<T> {
    hasError: boolean;
    message: string;
    data: T;
}
declare enum HttpStatusCode {
    Continue = 100,
    SwitchingProtocols = 101,
    Processing = 102,
    EarlyHints = 103,
    OK = 200,
    Created = 201,
    Accepted = 202,
    NonAuthoritativeInformation = 203,
    NoContent = 204,
    ResetContent = 205,
    PartialContent = 206,
    MultiStatus = 207,
    AlreadyReported = 208,
    IMUsed = 226,
    Ambiguous = 300,
    MultipleChoices = 300,
    Moved = 301,
    MovedPermanently = 301,
    Found = 302,
    Redirect = 302,
    RedirectMethod = 303,
    SeeOther = 303,
    NotModified = 304,
    UseProxy = 305,
    Unused = 306,
    RedirectKeepVerb = 307,
    TemporaryRedirect = 307,
    PermanentRedirect = 308,
    BadRequest = 400,
    Unauthorized = 401,
    PaymentRequired = 402,
    Forbidden = 403,
    NotFound = 404,
    MethodNotAllowed = 405,
    NotAcceptable = 406,
    ProxyAuthenticationRequired = 407,
    RequestTimeout = 408,
    Conflict = 409,
    Gone = 410,
    LengthRequired = 411,
    PreconditionFailed = 412,
    RequestEntityTooLarge = 413,
    RequestUriTooLong = 414,
    UnsupportedMediaType = 415,
    RequestedRangeNotSatisfiable = 416,
    ExpectationFailed = 417,
    MisdirectedRequest = 421,
    UnprocessableEntity = 422,
    Locked = 423,
    FailedDependency = 424,
    UpgradeRequired = 426,
    PreconditionRequired = 428,
    TooManyRequests = 429,
    RequestHeaderFieldsTooLarge = 431,
    UnavailableForLegalReasons = 451,
    InternalServerError = 500,
    NotImplemented = 501,
    BadGateway = 502,
    ServiceUnavailable = 503,
    GatewayTimeout = 504,
    HttpVersionNotSupported = 505,
    VariantAlsoNegotiates = 506,
    InsufficientStorage = 507,
    LoopDetected = 508,
    NotExtended = 510,
    NetworkAuthenticationRequired = 511
}

declare abstract class GenesisId {
    static NewGenesisId(): string;
    static NewGenesisIdWithSize(size: number): string;
    static GenerateUID(length: number): string;
}

declare const provideIcons: () => Array<Provider | EnvironmentProviders>;

declare class IconsService {
    /**
     * Constructor
     */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<IconsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IconsService>;
}

declare class SafeHtmlPipePipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(html: any): _angular_platform_browser.SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipePipe, "safeHtmlPipe", true>;
}

declare class TimeOnlyPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: TimeOnly): string;
    private timeFormat;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeOnlyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TimeOnlyPipe, "timeonly", true>;
}

type FormatSettings = {
    indent: number;
    lineNumbers: boolean;
    linkUrls: boolean;
    linksNewTab: boolean;
    quoteKeys: boolean;
    trailingCommas: boolean;
};
type FormatOptions = Partial<FormatSettings>;
type JsonType = 'key' | 'string' | 'number' | 'boolean' | 'null' | 'mark';
declare abstract class PrettyPrintJson {
    static toHtml(data: unknown, options?: FormatOptions): string;
}

declare abstract class CommonDatas {
    static genders: any[];
    static languages: any[];
    static userTypes: any[];
}

type Params = Record<string, any>;
declare class RouteService<T> {
    raw: T;
    constructor(routes: T);
    builder(route: string, params: Params): string;
}

declare class TenantApiService {
    private httpClient;
    private authService;
    private appsService;
    private navigationService;
    config: ApiClientConfig;
    constructor(httpClient: HttpClient, authService: AuthService, appsService: AppsService, navigationService: NavigationService, config: ApiClientConfig);
    getNavigations(appCode: string): Observable<GenesisNavigationItem[]>;
    getAppsByUser(): Observable<any>;
    getCallObservable(message: string, params?: Object): Observable<any>;
    private toHttpParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<TenantApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TenantApiService>;
}

declare class TranslocoHttpLoader implements TranslocoLoader {
    private _httpClient;
    /**
     * Constructor
     */
    constructor(_httpClient: HttpClient);
    /**
     * Get translation
     *
     * @param lang
     */
    getTranslation(lang: string): Observable<Translation>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslocoHttpLoader, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TranslocoHttpLoader>;
}

declare const provideTranslocoShell: () => Provider[];

export { ApplicationsComponent, AppsService, BreadcrumbComponent, BreadcrumbService, CallbackComponent, ChatAgentService, ChildSidebarComponent, ClassyLayoutComponent, CommonDatas, GENESIS_CONFIG, GENESIS_VERSION, GenesisAlertComponent, GenesisAlertService, GenesisBreadcrumbsComponent, GenesisCardComponent, GenesisChatAgentComponent, GenesisChildSidebarComponent, GenesisConfigService, GenesisDrawerComponent, GenesisFullscreenComponent, GenesisHorizontalNavigationComponent, GenesisId, GenesisLoadingBarComponent, GenesisMediaWatcherService, GenesisNavigationService, GenesisPlatformService, GenesisScrollResetDirective, GenesisScrollbarDirective, GenesisSplashScreenService, GenesisUtilsService, GenesisVerticalNavigationComponent, HttpStatusCode, IconsService, InvitationComponent, InvitationService, LanguagesComponent, LayoutComponent, LoginComponent, LogoutComponent, NavigationService, NotificationsComponent, PrettyPrintJson, RouteService, SafeHtmlPipePipe, ServiceModule, ShortcutsComponent, ShortcutsService, TenantApiService, ThemeSwitchComponent, TimeOnlyPipe, TranslocoHttpLoader, UserComponent, Version, genesisAnimations, provideIcons, provideTranslocoShell };
export type { BreadcrumbsModel, FSDocument, FSDocumentElement, FormatOptions, FormatSettings, GenesisAlertAppearance, GenesisAlertType, GenesisCardFace, GenesisConfig, GenesisNavigationItem, GenesisVerticalNavigationAppearance, GenesisVerticalNavigationMode, GenesisVerticalNavigationPosition, IApps, ILanguageDropdownItem, IResponse, InvitationModel, JsonType, Navigation, Scheme, Screens, Shortcut, Theme, Themes };