import * as _angular_core from '@angular/core';
import { OnInit, WritableSignal, Signal, InjectionToken } from '@angular/core';
import { Router, Route, RouteReuseStrategy, ActivatedRouteSnapshot, DetachedRouteHandle } from '@angular/router';
import { AuthUserMst, menuResponseData, CoreSystemEntity, AcaAcademicYear, designConfigResponseData, designConfigControllerResponse, ISytmLayout, MDesignConfig, IEnvironmentConfig, SystemThemeControllerRespoonse, SystemThemesListControllerRespoonse, MSystemThemeUserPreferencesRequest, SystemThemeUserPreferencesControllerRespoonse, MFileManager, fileManagerControllerResponse, CoreEntityAccessPassManagement, MCoreEntityAccessPassManagement, CoreEntityAccessPassManagementControllerResponse, MCoreEntityAccessPassManagementGetByIdPayload, CoreEntityAccessPassManagementByIdControllerResponse, MCoreEntityAccessPassManagementInsertUpdate, CoreEntityAccessPassManagementInsertUpdateControllerResponse, MCoreEntityAccessPassManagementDeletePayload, CoreEntityAccessPassManagementDeleteControllerResponse, MCoreEntityAccessPassManagementToggleStatusPayload, CoreEntityAccessPassManagementToggleStatusControllerResponse, CoreSystemEntityListResponse } from 'cloud-ide-lms-model';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import { CideEleBreadcrumbComponent } from 'cloud-ide-element';
import { Title } from '@angular/platform-browser';
import { FormGroup } from '@angular/forms';

declare class CloudIdeLayoutService {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudIdeLayoutService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CloudIdeLayoutService>;
}

declare class CloudIdeLayoutComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudIdeLayoutComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudIdeLayoutComponent, "cide-lyt-wrapper", never, {}, {}, never, never, true, never>;
}

declare class AppStateHelperService {
    private appStateService;
    private sidebarService;
    readonly currentUser: _angular_core.Signal<AuthUserMst | null>;
    readonly isAuthenticated: _angular_core.Signal<boolean>;
    readonly userInfo: _angular_core.Signal<{
        id: string | undefined;
        name: string;
        email: string | undefined;
        role: string;
    } | null>;
    readonly activeModule: _angular_core.Signal<menuResponseData | null>;
    readonly activeModuleInfo: _angular_core.Signal<{
        id: string;
        title: string;
        icon: string;
        path: string;
        type: string;
    } | null>;
    readonly activeEntity: _angular_core.Signal<CoreSystemEntity | null>;
    readonly activeAcademicYear: _angular_core.Signal<AcaAcademicYear | null>;
    /**
     * Get current user value (non-reactive)
     */
    getCurrentUser(): AuthUserMst | null;
    /**
     * Set user data
     */
    setUser(user: AuthUserMst | null): void;
    /**
     * Update user data (partial update)
     */
    updateUser(updates: Partial<AuthUserMst>): void;
    /**
     * Clear user data
     */
    clearUser(): void;
    /**
     * Check if user is authenticated
     */
    isUserAuthenticated(): boolean;
    /**
     * Get user info object
     */
    getUserInfo(): {
        id: string | undefined;
        name: string;
        email: string | undefined;
        role: string;
    } | null;
    /**
     * Get user ID
     */
    getUserId(): string | null;
    /**
     * Get user name
     */
    getUserName(): string | null;
    /**
     * Get user email
     */
    getUserEmail(): string | null;
    /**
     * Get user username
     */
    getUserUsername(): string | null;
    /**
     * Get user full name
     */
    getUserFullName(): string | null;
    /**
     * Get user first name
     */
    getUserFirstName(): string | null;
    /**
     * Get user last name
     */
    getUserLastName(): string | null;
    /**
     * Get user mobile number
     */
    getUserMobile(): number | null;
    /**
     * Set the active module
     */
    setActiveModule(module: menuResponseData | null): void;
    /**
     * Get active module value (non-reactive)
     */
    getActiveModule(): menuResponseData | null;
    /**
     * Get active module info
     */
    getActiveModuleInfo(): {
        id: string;
        title: string;
        icon: string;
        path: string;
        type: string;
    } | null;
    /**
     * Get active module ID
     */
    getActiveModuleId(): string | null;
    /**
     * Get active module title
     */
    getActiveModuleTitle(): string | null;
    /**
     * Get active module icon
     */
    getActiveModuleIcon(): string | null;
    /**
     * Set a module as active by its ID
     * This replaces the previous isModuleActive method to use setActiveModule instead of getActiveModuleId
     */
    setActiveModuleById(moduleId: string): Observable<boolean>;
    /**
     * Check if a module is active (keeping the original functionality for backward compatibility)
     */
    isModuleActive(moduleId: string): boolean;
    /**
     * Set the active entity
     */
    setActiveEntity(entity: CoreSystemEntity | null): void;
    /**
     * Get active entity value (non-reactive)
     */
    getActiveEntity(): CoreSystemEntity | null;
    /**
     * Get active entity ID
     */
    getActiveEntityId(): string;
    /**
     * Get active entity name
     */
    getActiveEntityName(): string | null;
    /**
     * Get active entity code
     */
    getActiveEntityCode(): string | null;
    /**
     * Set the active academic year
     */
    setActiveAcademicYear(academicYear: AcaAcademicYear | null): void;
    /**
     * Get active academic year value (non-reactive)
     */
    getActiveAcademicYear(): AcaAcademicYear | null;
    /**
     * Get active academic year ID
     */
    getActiveAcademicYearId(): string | null;
    /**
     * Set the student model
     */
    setStudentModel(model: any | null): void;
    /**
     * Manually refresh state from localStorage
     */
    refreshFromLocalStorage(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppStateHelperService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AppStateHelperService>;
}

declare class CideLytSharedWrapperComponent implements OnInit {
    breadcrumb: _angular_core.Signal<CideEleBreadcrumbComponent | undefined>;
    shared_wrapper_setup_param: _angular_core.InputSignal<Partial<CideLytSharedWrapperSetupParam>>;
    breadcrumb_data: _angular_core.InputSignal<BreadcrumbItem[]>;
    page_data: _angular_core.WritableSignal<designConfigResponseData>;
    private sharedService;
    private sidedrawerService;
    protected router: Router;
    protected appState: AppStateHelperService;
    private componentContextService;
    private additionalBreadcrumbItems;
    private fullBreadcrumbItems;
    constructor();
    ngOnInit(): void;
    /**
     * Add additional breadcrumb items that will be appended after the default Module > Current Page path
     * @param items Array of breadcrumb items to append
     */
    addBreadcrumbItems(items: BreadcrumbItem[]): void;
    /**
     * Clear additional breadcrumb items (keeps only default Module > Current Page)
     */
    clearAdditionalBreadcrumbItems(): void;
    /**
     * Set additional breadcrumb items (replaces any existing additional items)
     * @param items Array of breadcrumb items to set
     */
    setBreadcrumbItems(items: BreadcrumbItem[]): void;
    /**
     * Handle breadcrumb home button click - navigate to control panel home
     */
    onBreadcrumbHomeClick(): void;
    /**
     * Close the current component context
     * - If in a tab: closes the tab
     * - If in a floating container: closes the floating container
     * - If neither: navigates to fallback route (optional)
     *
     * This method can be called from child components to close themselves
     * without needing to know their context (tab vs floating container)
     *
     * @param fallbackRoute Optional route to navigate to if not in tab or floating container
     * @param containerId Optional specific container ID to close (if known)
     */
    close(fallbackRoute?: string[], containerId?: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytSharedWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytSharedWrapperComponent, "cide-lyt-shared-wrapper", never, { "shared_wrapper_setup_param": { "alias": "shared_wrapper_setup_param"; "required": false; "isSignal": true; }; "breadcrumb_data": { "alias": "breadcrumb_data"; "required": false; "isSignal": true; }; }, {}, never, ["[breadcrumb-actions]", "*"], true, never>;
}
interface CideLytSharedWrapperSetupParam {
    sypg_page_code: string;
}
interface BreadcrumbItem {
    id: string;
    label: string;
    icon?: string;
    url?: string;
}

interface CachedPageData {
    request: Partial<CideLytSharedWrapperSetupParam>;
    response: designConfigControllerResponse;
    timestamp: number;
    ttl: number;
}
declare class CideLytSharedService {
    private pageDataCacheSignal;
    private loadingStateSignal;
    private pageDataSignal;
    readonly pageDataCache: _angular_core.Signal<{
        [key: string]: CachedPageData;
    }>;
    readonly loadingStates: _angular_core.Signal<{
        [key: string]: boolean;
    }>;
    readonly pageDataStore: _angular_core.Signal<{
        [key: string]: designConfigControllerResponse;
    }>;
    readonly cacheInfo: _angular_core.Signal<{
        totalCached: number;
        validCached: number;
        expiredCached: number;
    }>;
    private inflightRequests;
    private readonly DEFAULT_CACHE_TTL;
    private elementService;
    private http;
    titleService: Title;
    private sidebarService;
    private headerService;
    private footerService;
    private consoleService;
    private sidedrawerService;
    private router;
    private appState;
    private appStateService;
    private routeSubscription?;
    private pageDataSubscription?;
    private tabManagementCallback?;
    private requestVisibilityCallback?;
    constructor();
    /**
     * Register tab management callback from request service
     * This allows shared service to call request service without circular dependency
     */
    registerTabManagement(callback: (currentRoutePath: string, queryParams: Record<string, unknown>, layout: ISytmLayout, pageData: designConfigControllerResponse, pageCode: string) => void): void;
    /**
     * Fetch breadcrumb navigation items for a page code from backend
     * Expected response shape: data.path: Array<{ id|_id|code, title|name|sypg_title, icon?, url|path|sypg_path }>
     */
    getBreadcrumbNavigation(pageCode: string): Observable<Array<{
        id: string;
        label: string;
        icon?: string;
        path?: string;
    }>>;
    /**
     * Register request visibility callback from request service
     * This allows shared service to control request wrapper visibility
     */
    registerRequestVisibility(callback: (show: boolean) => void): void;
    /**
     * Enhanced loadPageData with caching and deduplication
     * @param body - Request payload
     * @param forceRefresh - Force API call even if cached data exists
     * @param customTTL - Custom cache TTL in milliseconds
     */
    loadPageData(body: MDesignConfig, forceRefresh?: boolean, customTTL?: number): Observable<designConfigControllerResponse>;
    /**
     * Consolidated method to load and process page data
     * This replaces the separate calls in request service and shared wrapper
     */
    loadAndProcessPageData(body: MDesignConfig, options?: {
        forceRefresh?: boolean;
        customTTL?: number;
        setTitle?: boolean;
        setSidebarContext?: boolean;
        updateLayout?: boolean;
    }): Observable<designConfigControllerResponse>;
    /**
     * Get cached page data without making API call
     */
    getCachedPageData(pageCode: string): designConfigControllerResponse | null;
    /**
     * Get page rights only (without loading full page config)
     * This is a lightweight endpoint that only fetches rights
     * @param pageCode - Page code to get rights for
     * @returns Observable with rights data
     */
    getPageRights(pageCode: string): Observable<{
        success: boolean;
        code: number;
        data?: {
            rights: {
                [permissionId: string]: {
                    allowed: boolean;
                    source: 'role' | 'exception';
                };
            };
            pageCode: string;
        };
        message: string;
    }>;
    /**
     * Check if loading for a specific page code
     */
    isLoading(pageCode: string): boolean;
    /**
     * Invalidate cache for specific page code
     */
    invalidateCache(pageCode: string): void;
    /**
     * Clear all cached data
     */
    clearAllCache(): void;
    /**
     * Preload page data for better performance
     */
    preloadPageData(pageCodes: string[]): void;
    private hasValidCache;
    private isCacheValid;
    private cachePageData;
    private setLoadingState;
    private cleanExpiredCache;
    setPageData(page_data_response: designConfigControllerResponse, page_data_payload: Partial<CideLytSharedWrapperSetupParam>): void;
    /**
     * Handle route changes - moved from request service for better architecture
     * This method loads page data and calls request service to manage tabs
     */
    private handleRouteChange;
    /**
     * Handle tab request by calling request service
     */
    private handleTabRequest;
    /**
     * Sync the active menu in the sidebar based on the loaded page data.
     * This ensures the correct module is highlighted in the sidebar.
     */
    private syncSidebarActiveMenu;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytSharedService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytSharedService>;
}

/**
 * Service to detect component context (tab or floating container) and close appropriately
 * This allows components to close themselves without knowing their context
 */
declare class ComponentContextService {
    private requestService;
    private floatingContainerService;
    private router;
    private route;
    /**
     * Close the current component context
     * - If in a tab: closes the tab
     * - If in a floating container: closes the floating container
     * - If neither: navigates to a fallback route (optional)
     *
     * @param fallbackRoute Optional route to navigate to if not in tab or floating container
     * @param containerId Optional specific container ID to close (if known)
     */
    close(fallbackRoute?: string[], containerId?: string): void;
    /**
     * Check if component is in a tab
     */
    isInTab(): boolean;
    /**
     * Check if component is in a floating container
     */
    isInFloatingContainer(): boolean;
    /**
     * Get the current context type
     */
    getContextType(): 'tab' | 'floating-container' | 'none';
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentContextService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComponentContextService>;
}

/**
 * Common Rights Service
 * Provides a centralized way to check user permissions based on page rights
 *
 * Usage:
 * ```typescript
 * private rightsService = inject(RightsService);
 *
 * ngOnInit() {
 *   this.rightsService.initializeRights('fdsk_lead_config');
 * }
 *
 * // Check if user has a specific right
 * if (this.rightsService.hasRight('CREATE')) {
 *   // Show create button
 * }
 *
 * // Get all rights for current page
 * const rights = this.rightsService.getRights();
 * ```
 */
declare class RightsService {
    private sharedService;
    private appStateService;
    private currentPageCode;
    private rightsOnlyCache;
    private loadingRights;
    constructor();
    private rightsComputed;
    /**
     * Initialize rights for a specific page
     * Call this in component ngOnInit with the page code
     * @param pageCode - Page code to initialize rights for
     * @param forceRefresh - If true, invalidates cache and forces refresh
     * @param fetchRightsOnly - If true, uses the lightweight rights-only endpoint instead of full page config.
     *                          If 'auto', automatically fetches rights-only if not already loaded.
     */
    initializeRights(pageCode: string, forceRefresh?: boolean, fetchRightsOnly?: boolean | 'auto'): void;
    /**
     * Load rights only using the lightweight endpoint
     * This is useful when you only need rights without full page config
     * @param pageCode - Page code to load rights for
     */
    loadRightsOnly(pageCode: string): void;
    /**
     * Get current rights (reactive)
     */
    private getCurrentRights;
    /**
     * Check if user has a specific right
     * @param rightCode - The right code to check (e.g., 'CREATE', 'EDIT', 'DELETE', 'VIEW')
     * @returns true if the user has the right, false otherwise
     */
    hasRight(rightCode: string): boolean;
    /**
     * Check if user has any of the specified rights
     * @param rightCodes - Array of right codes to check
     * @returns true if user has at least one of the rights
     */
    hasAnyRight(rightCodes: string[]): boolean;
    /**
     * Check if user has all of the specified rights
     * @param rightCodes - Array of right codes to check
     * @returns true if user has all of the rights
     */
    hasAllRights(rightCodes: string[]): boolean;
    /**
     * Get the source of a right (role or exception)
     * @param rightCode - The right code
     * @returns 'role' | 'exception' | null
     */
    getRightSource(rightCode: string): 'role' | 'exception' | null;
    /**
     * Get all rights for the current page
     * @returns Object containing all rights with their allowed status and source
     */
    getRights(): {
        [permissionId: string]: {
            allowed: boolean;
            source: 'role' | 'exception';
        };
    };
    /**
     * Get all allowed rights
     * @returns Array of right codes that are allowed
     */
    getAllowedRights(): string[];
    /**
     * Get rights as a computed signal (for reactive templates)
     * @returns Computed signal that updates when rights change
     */
    getRightsSignal(): _angular_core.Signal<{
        [permissionId: string]: {
            allowed: boolean;
            source: "role" | "exception";
        };
    }>;
    /**
     * Check rights for a specific page code (without initializing)
     * Useful for checking rights of other pages
     */
    checkRightsForPage(pageCode: string): {
        [permissionId: string]: {
            allowed: boolean;
            source: 'role' | 'exception';
        };
    };
    /**
     * Check if user has a specific right for a specific page
     */
    hasRightForPage(pageCode: string, rightCode: string): boolean;
    /**
     * Check if rights are loaded for the current page
     * @returns true if rights have been loaded (even if empty)
     */
    areRightsLoaded(): boolean;
    /**
     * Check if rights are currently loading for the current page
     */
    isPageRightsLoading(): boolean;
    /**
     * Get current page code
     */
    getCurrentPageCode(): string;
    /**
     * Force refresh rights by invalidating cache
     * Call this after rights are updated in the database
     * @param useRightsOnlyEndpoint - If true, uses the lightweight rights-only endpoint
     */
    refreshRights(useRightsOnlyEndpoint?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RightsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RightsService>;
}

declare const layoutRoutes: Route;
declare const layoutControlPannelChildRoutes: Route[];

/**
 * A custom route reuse strategy that allows storing and retrieving routes
 * to persist component state, especially for tabbed navigation.
 */
declare class CustomRouteReuseStrategy implements RouteReuseStrategy {
    private injector;
    private storedRoutes;
    private routesToDestroy;
    private getPathKey;
    shouldDetach(route: ActivatedRouteSnapshot): boolean;
    store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle | null): void;
    doNotStore(pathKey: string): void;
    shouldAttach(route: ActivatedRouteSnapshot): boolean;
    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
    private isHandleDestroyed;
    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
    clearStoredRoute(pathKey: string): void;
    clearAllStoredRoutes(): void;
    getStoredRoutesCount(): number;
    getAllStoredRouteKeys(): string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomRouteReuseStrategy, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CustomRouteReuseStrategy>;
}

interface TabInfo {
    id: string;
    title: string;
    route: string;
    params?: Record<string, unknown>;
    active: boolean;
    sytm_page_id_sypg: string;
    themeId: string;
    loadedComponent?: unknown;
    scrollTop?: number;
    scrollLeft?: number;
    layout?: ISytmLayout;
}
interface PageDataResponse {
    data?: {
        page?: {
            sypg_title?: string;
        };
    };
}
declare class CideLytRequestService {
    requestVisible: boolean;
    tabsSignal: WritableSignal<TabInfo[]>;
    activeTabIdSignal: WritableSignal<string | null>;
    tabs: Signal<TabInfo[]>;
    activeTabId: Signal<string | null>;
    activeTab: Signal<TabInfo | undefined>;
    private router;
    private routeReuseStrategy;
    private tabStateService;
    private sidedrawerService;
    private sharedService;
    private floatingContainerService;
    private appStateService;
    constructor();
    /**
     * Handle request visibility changes from shared service
     */
    private handleRequestVisibility;
    /**
     * Handle sidebar sync when tab becomes active
     */
    private handleSidebarSync;
    /**
     * Handle route-based tab management - called by shared service
     * This method checks for existing tabs and creates/activates as needed
     */
    handleRouteBasedTabManagement(currentRoutePath: string, queryParams: Record<string, unknown>, layout: ISytmLayout, pageData: PageDataResponse, pageCode: string): void;
    addTab(title: string, route: string, params?: Record<string, unknown>, layout?: ISytmLayout): string;
    activateTab(tabId: string): void;
    closeTab(id: string): void;
    /**
     * Close all tabs and navigate to home
     * This is used when entity changes to ensure all components are destroyed and refreshed
     * IMPORTANT: This method ensures all tab components are removed from DOM by:
     * 1. Clearing all stored routes from route reuse strategy (destroys component instances)
     * 2. Clearing all tabs from TabStateService
     * 3. Navigating to home to clear router outlet
     */
    closeAllTabs(): void;
    hideRequest(): void;
    showRequest(): void;
    private generateId;
    updateTabScrollPosition(tabId: string, scrollTop: number, scrollLeft: number): void;
    /**
     * Force refresh a route by clearing its cached state
     * This is useful when you want to ensure a clean component state
     * @param route The route path to refresh
     * @param params Optional query parameters
     */
    forceRefreshRoute(route: string, params?: Record<string, unknown>): void;
    /**
     * Get information about cached routes (useful for debugging)
     */
    getCachedRoutesInfo(): {
        count: number;
        routes: string[];
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytRequestService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytRequestService>;
}

interface AppState {
    currentUser: AuthUserMst | null;
    activeModule: menuResponseData | null;
    activeEntity: CoreSystemEntity | null;
    activeAcademicYear: AcaAcademicYear | null;
    studentModel: any | null;
}
declare class AppStateService {
    private fileManagerService;
    private currentUserSignal;
    private activeModuleSignal;
    private activeEntitySignal;
    private activeAcademicYearSignal;
    private studentModelSignal;
    private entityChangeHandlerInitialized;
    private entityChangeCallbacks;
    readonly currentUser: _angular_core.Signal<AuthUserMst | null>;
    readonly activeModule: _angular_core.Signal<menuResponseData | null>;
    readonly activeEntity: _angular_core.Signal<CoreSystemEntity | null>;
    readonly activeAcademicYear: _angular_core.Signal<AcaAcademicYear | null>;
    readonly studentModel: _angular_core.Signal<any>;
    readonly isAuthenticated: _angular_core.Signal<boolean>;
    readonly userInfo: _angular_core.Signal<{
        id: string | undefined;
        name: string;
        email: string | undefined;
        role: string;
    } | null>;
    readonly activeModuleInfo: _angular_core.Signal<{
        id: string;
        title: string;
        icon: string;
        path: string;
        type: string;
    } | null>;
    constructor();
    /**
     * Set the current user
     */
    setUser(user: AuthUserMst | null): void;
    /**
     * Update user data (partial update)
     */
    updateUser(updates: Partial<AuthUserMst>): void;
    /**
     * Clear user data
     */
    clearUser(): void;
    /**
     * Get current user value (non-reactive)
     */
    getUserValue(): AuthUserMst | null;
    /**
     * Set the active module
     */
    setActiveModule(module: menuResponseData | null): void;
    /**
     * Get active module value (non-reactive)
     */
    getActiveModuleValue(): menuResponseData | null;
    /**
     * Set the active entity
     */
    setActiveEntity(entity: CoreSystemEntity | null): void;
    /**
     * Get active entity value (non-reactive)
     */
    getActiveEntityValue(): CoreSystemEntity | null;
    /**
     * Set the active academic year
     */
    setActiveAcademicYear(academicYear: AcaAcademicYear | null): void;
    /**
     * Get active academic year value (non-reactive)
     */
    getActiveAcademicYearValue(): AcaAcademicYear | null;
    /**
     * Set the student model
     */
    setStudentModel(model: any | null): void;
    /**
     * Get student model value (non-reactive)
     */
    getStudentModelValue(): any | null;
    /**
     * Register a callback to be called when entity changes
     * This allows other services to react to entity changes without creating circular dependencies
     * @param callback Function to call when entity changes, receives the new entity (or null if cleared)
     */
    registerEntityChangeHandler(callback: (entity: CoreSystemEntity | null) => void): void;
    /**
     * Unregister an entity change callback
     * @param callback The callback function to remove
     */
    unregisterEntityChangeHandler(callback: (entity: CoreSystemEntity | null) => void): void;
    /**
     * Manually refresh state from localStorage
     * Call this method when you need to sync with external localStorage changes
     */
    refreshFromLocalStorage(): void;
    /**
     * Check if localStorage is available (browser environment)
     */
    private isLocalStorageAvailable;
    /**
     * Save state to localStorage
     */
    private saveToLocalStorage;
    /**
     * Load state from localStorage
     */
    private loadFromLocalStorage;
    /**
     * Setup storage event listener to handle external localStorage changes
     */
    private setupStorageListener;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AppStateService>;
}

type UserStatus = 'online' | 'offline' | 'away' | 'busy' | 'do-not-disturb';
interface UserStatusData {
    status: UserStatus;
    lastActive: Date;
    message?: string;
}
declare class CideLytUserStatusService {
    private _userStatus;
    readonly userStatus: _angular_core.Signal<UserStatusData>;
    readonly isOnline: _angular_core.Signal<boolean>;
    readonly statusColor: _angular_core.Signal<string>;
    readonly statusText: _angular_core.Signal<string>;
    private statusSubject;
    readonly status$: rxjs.Observable<UserStatusData>;
    private lastActivityTime;
    private autoAwayTimeout;
    private autoAwayEnabled;
    constructor();
    /**
     * Sets the user status
     * @param status The new status to set
     * @param message Optional custom status message
     */
    setStatus(status: UserStatus, message?: string): void;
    /**
     * Marks user as active (resets away timer)
     */
    markUserActive(): void;
    /**
     * Gets CSS class for status color
     */
    private getStatusColor;
    /**
     * Gets human-readable status text
     */
    private getStatusText;
    private getBaseStatusText;
    /**
     * Initialize activity tracking for auto-away
     */
    private initializeActivityTracking;
    /**
     * Start the auto-away timer
     */
    private startAutoAwayTimer;
    /**
     * Enable or disable auto-away functionality
     */
    setAutoAwayEnabled(enabled: boolean): void;
    /**
     * Set the auto-away timeout (in milliseconds)
     */
    setAutoAwayTimeout(timeout: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytUserStatusService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytUserStatusService>;
}

declare const ENVIRONMENT_CONFIG: InjectionToken<IEnvironmentConfig>;
interface Theme {
    [key: string]: string;
}
/**
 * Utility function to convert database format keys to CSS format and handle units
 * @param key - The database format key (e.g., 'font_size_xxxl')
 * @param value - The value to be set
 * @returns Object with cssVarName and processed value
 */
declare function processThemeVariable(key: string, value: string): {
    cssVarName: string;
    processedValue: string;
};
/**
 * Sets a single CSS variable on the document root element
 * @param key - The database format key (e.g., 'font_size_xxxl')
 * @param value - The value to be set
 * @param platformId - Platform ID for browser check
 */
declare function setCSSVariable(key: string, value: string, platformId: object): void;
declare class CideLytThemeService {
    private selectedThemeSignal;
    selectedTheme: _angular_core.Signal<string>;
    private http;
    private platformId;
    private environment;
    /**
     * Fetches the theme from the API and applies it to the document.
     * This method is intended to be called when the theme should actually be applied.
     */
    fetchAndApplyTheme(): Observable<SystemThemeControllerRespoonse>;
    /**
     * Fetches the list of system themes from the API.
     */
    fetchSystemThemesList(): Observable<SystemThemesListControllerRespoonse>;
    /**
     * Internal method to fetch the theme from the API and apply it.
     */
    loadTheme(): Observable<SystemThemeControllerRespoonse>;
    /**
     * Sets the CSS variables on the root element.
     * @param theme - An object where keys are CSS variable names (e.g., '--color-text-body')
     * and values are the color strings (e.g., '#ffffff').
     */
    private applyTheme;
    /**
     * Saves the system theme user preferences.
     * @param themeVars - The theme variables to save.
     * @returns An observable of the system theme user preferences.
     */
    saveSystemThemeUserPreferences(themeVars: MSystemThemeUserPreferencesRequest): Observable<SystemThemeUserPreferencesControllerRespoonse>;
    /**
     * Updates a single CSS variable using the utility function
     * @param key - The database format key (e.g., 'font_size_xxxl')
     * @param value - The value to be set
     */
    updateCSSVariable(key: string, value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytThemeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytThemeService>;
}
/**
 * Factory function for APP_INITIALIZER.
 * This function is used in your app.config.ts.
 * It conditionally triggers theme loading based on the environment setting.
 */
declare function themeFactory(themeService: CideLytThemeService, environmentConfig: IEnvironmentConfig): () => Observable<SystemThemeControllerRespoonse | undefined>;

declare class CacheManagerService {
    private sharedService;
    readonly cacheStats: _angular_core.Signal<{
        hitRatio: number;
        memoryEstimate: string;
        totalCached: number;
        validCached: number;
        expiredCached: number;
    }>;
    readonly isLoading: (pageCode: string) => boolean;
    readonly getCachedData: (pageCode: string) => designConfigControllerResponse | null;
    /**
     * Get page data with caching - this is the main method components should use
     */
    getPageData(pageCode: string, forceRefresh?: boolean): Observable<designConfigControllerResponse>;
    /**
     * Preload multiple pages for better performance
     */
    preloadPages(pageCodes: string[]): void;
    /**
     * Invalidate specific page cache
     */
    invalidatePage(pageCode: string): void;
    /**
     * Clear all cache
     */
    clearCache(): void;
    /**
     * Get cache status for debugging
     */
    getCacheStatus(): {
        pageCode: string;
        cached: boolean;
        expired: boolean;
        loading: boolean;
    }[];
    /**
     * Estimate memory usage of cache (rough estimate)
     */
    private estimateCacheMemoryUsage;
    /**
     * Check if cache entry is valid
     */
    private isCacheValid;
    /**
     * Export cache data for debugging or backup
     */
    exportCacheData(): string;
    /**
     * Get performance metrics
     */
    getPerformanceMetrics(): {
        totalPages: number;
        cachedPages: number;
        loadingPages: number;
        cacheHitRatio: number;
        averageResponseTime?: number;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CacheManagerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CacheManagerService>;
}

declare class CideLytFileManagerService {
    private http;
    getFileDetails(body: MFileManager): Observable<fileManagerControllerResponse>;
    uploadFile(file: File, additionalData?: any): Observable<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytFileManagerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytFileManagerService>;
}

/**
 * Notification Settings Interface
 */
interface NotificationSettings {
    soundEnabled: boolean;
    soundVolume: number;
    soundType: 'default' | 'gentle' | 'alert' | 'chime' | 'none';
    snoozeEnabled: boolean;
    snoozeDuration: number;
    quietHoursEnabled: boolean;
    quietHoursStart: string;
    quietHoursEnd: string;
    channelInApp: boolean;
    channelEmail: boolean;
    channelSms: boolean;
    desktopNotifications: boolean;
    showPreview: boolean;
    groupNotifications: boolean;
}
/**
 * Notification Settings Service
 * Manages user notification preferences with localStorage persistence
 */
declare class NotificationSettingsService {
    private readonly settingsSignal;
    readonly settings: _angular_core.Signal<NotificationSettings>;
    readonly soundEnabled: _angular_core.Signal<boolean>;
    readonly soundVolume: _angular_core.Signal<number>;
    readonly soundType: _angular_core.Signal<"none" | "default" | "gentle" | "alert" | "chime">;
    readonly quietHoursEnabled: _angular_core.Signal<boolean>;
    readonly isQuietHours: _angular_core.Signal<boolean>;
    constructor();
    /**
     * Update notification settings
     */
    updateSettings(updates: Partial<NotificationSettings>): void;
    /**
     * Reset to default settings
     */
    reset(): void;
    /**
     * Check if currently in quiet hours
     */
    isCurrentlyQuietHours(): boolean;
    /**
     * Convert time string (HH:mm) to minutes since midnight
     */
    private timeToMinutes;
    /**
     * Play notification sound based on settings
     */
    playNotificationSound(): void;
    /**
     * Play sound with the given audio context
     */
    private playSoundWithContext;
    /**
     * Play a single tone
     */
    private playTone;
    /**
     * Load settings from localStorage
     */
    private loadFromLocalStorage;
    /**
     * Save settings to localStorage
     */
    private saveToLocalStorage;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationSettingsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationSettingsService>;
}

interface EntityWithPermissions extends CoreSystemEntity {
    permissions: CoreEntityAccessPassManagement | null;
    canView: boolean;
    canEdit: boolean;
    isOwner: boolean;
    isActive: boolean;
}
declare class CideLytFloatingEntityRightsSharingComponent implements OnInit {
    data: _angular_core.InputSignal<any>;
    close: _angular_core.OutputEmitterRef<void>;
    save: _angular_core.OutputEmitterRef<any>;
    private pendingUpdates;
    pendingChangesCount: _angular_core.WritableSignal<number>;
    private entityDataCache;
    private readonly CACHE_DURATION;
    private fb;
    private entityService;
    private entityAccessPassService;
    private appState;
    selectedTab: _angular_core.WritableSignal<"user" | "hierarchy">;
    entities: _angular_core.WritableSignal<CoreSystemEntity[]>;
    selectedEntityId: _angular_core.WritableSignal<string>;
    entitiesLoading: _angular_core.WritableSignal<boolean>;
    accessPassLoading: _angular_core.WritableSignal<boolean>;
    saving: _angular_core.WritableSignal<boolean>;
    currentAccessPass: _angular_core.WritableSignal<CoreEntityAccessPassManagement | null>;
    accessPassList: _angular_core.WritableSignal<CoreEntityAccessPassManagement[]>;
    hierarchy: _angular_core.WritableSignal<CoreSystemEntity[]>;
    hierarchyLoading: _angular_core.WritableSignal<boolean>;
    entityPermissionsMap: _angular_core.Signal<Map<string, CoreEntityAccessPassManagement>>;
    entitiesWithPermissions: _angular_core.Signal<EntityWithPermissions[]>;
    rightsForm: FormGroup;
    ngOnInit(): void;
    /**
     * Track pending changes for batch update
     */
    private trackPendingChanges;
    /**
     * Get original values for an entity
     */
    private getOriginalValuesForEntity;
    /**
     * Check if there are actual changes between current and original values
     */
    private hasActualChanges;
    /**
     * Clear pending changes for a specific entity
     */
    private clearPendingChanges;
    /**
     * Clear all pending changes
     */
    private clearAllPendingChanges;
    /**
     * Check if cached data exists and is still valid
     */
    private getCachedEntityData;
    /**
     * Cache entity data
     */
    private setCachedEntityData;
    /**
     * Clear cache for specific entity (useful after updates)
     */
    private clearEntityCache;
    /**
     * Clear all cached data
     */
    private clearAllCache;
    /**
     * Check if entity has pending changes
     */
    hasPendingChanges(entityId: string): boolean;
    constructor();
    selectTab(tab: 'user' | 'hierarchy'): void;
    private initializeForm;
    loadEntities(): Promise<void>;
    selectEntity(entityId: string): void;
    /**
     * Populate form with cached data
     */
    private populateFormWithCachedData;
    /**
     * Set form values based on data or defaults
     */
    private setFormValues;
    loadRightsForSelectedEntity(entityId: string): Promise<void>;
    loadAccessPassData(): Promise<void>;
    saveRights(): Promise<void>;
    onCancel(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytFloatingEntityRightsSharingComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytFloatingEntityRightsSharingComponent, "cide-lyt-floating-entity-rights-sharing", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "close": "close"; "save": "save"; }, never, never, true, never>;
}

interface EntityRightsSharingData {
    syepm_access_passs_to: string;
    core_entity_access_pass_management: string;
    syepm_user_id_user: string;
}
declare class CideLytFloatingEntityRightsSharingService {
    private containerService;
    private http;
    private entityAccessPassListSubject;
    entityAccessPassList$: Observable<CoreEntityAccessPassManagement[]>;
    constructor();
    /**
     * Show entity rights sharing in floating container
     */
    show(data?: Signal<EntityRightsSharingData>): Promise<string>;
    /**
     * Hide entity rights sharing
     */
    hide(): void;
    /**
     * Register the entity rights sharing component
     */
    private registerEntityRightsSharingComponent;
    /**
     * Get entity access pass management list from API
     */
    getEntityAccessPassList(body: MCoreEntityAccessPassManagement): Observable<CoreEntityAccessPassManagementControllerResponse>;
    /**
     * Get entity access pass management by ID
     */
    getEntityAccessPassById(payload: MCoreEntityAccessPassManagementGetByIdPayload): Observable<CoreEntityAccessPassManagementByIdControllerResponse>;
    /**
     * Insert or update entity access pass management
     */
    insertUpdateEntityAccessPass(payload: MCoreEntityAccessPassManagementInsertUpdate): Observable<CoreEntityAccessPassManagementInsertUpdateControllerResponse>;
    /**
     * Delete entity access pass management
     */
    deleteEntityAccessPass(payload: MCoreEntityAccessPassManagementDeletePayload): Observable<CoreEntityAccessPassManagementDeleteControllerResponse>;
    /**
     * Toggle entity access pass management status
     */
    toggleEntityAccessPassStatus(payload: MCoreEntityAccessPassManagementToggleStatusPayload): Observable<CoreEntityAccessPassManagementToggleStatusControllerResponse>;
    /**
     * Get entity access pass management for specific user and entity
     * @param userId - User ID
     * @param entityId - Entity ID (the entity context)
     * @param coreEntityAccessPassManagement - The table name (e.g., 'core_entity_access_pass_management_sycad')
     * @param accessPassTo - Optional: The primary _id of the specific record whose access is being managed
     */
    getEntityAccessPassForUserAndEntity(userId: string, entityId: string, coreEntityAccessPassManagement: string, accessPassTo?: string): Observable<CoreEntityAccessPassManagementControllerResponse>;
    /**
     * Create or update entity access pass for user and entity
     * @param userId - User ID
     * @param entityId - Entity ID (the entity context)
     * @param accessPassTo - The primary _id of the specific record whose access is being managed (e.g., address _id from core_user_contact_addresses)
     * @param coreEntityAccessPassManagement - The table name (e.g., 'core_entity_access_pass_management_sycad')
     * @param rights - The access rights to be granted
     * @param existingId - Optional: Existing access pass ID for updates
     */
    saveEntityAccessPassForUserAndEntity(userId: string, entityId: string, accessPassTo: string, coreEntityAccessPassManagement: string, rights: {
        can_view?: boolean;
        can_edit?: boolean;
        is_owner?: boolean;
        syepm_isactive?: boolean;
    }, existingId?: string): Observable<CoreEntityAccessPassManagementInsertUpdateControllerResponse>;
    /**
     * Refresh the entity access pass list
     */
    private refreshEntityAccessPassList;
    /**
     * Handle HTTP errors
     */
    private handleError;
    /**
     * Get current entity access pass list
     */
    getCurrentEntityAccessPassList(): CoreEntityAccessPassManagement[];
    /**
     * Clear entity access pass list
     */
    clearEntityAccessPassList(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytFloatingEntityRightsSharingService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytFloatingEntityRightsSharingService>;
}

declare class CideLytFloatingEntitySelectionComponent implements OnInit {
    allowSwitching: _angular_core.InputSignal<boolean>;
    showActions: _angular_core.InputSignal<boolean>;
    mode: _angular_core.InputSignal<"selection" | "view">;
    onSelectCallback: _angular_core.InputSignal<((entity: CoreSystemEntityListResponse) => void) | undefined>;
    selectionMode: _angular_core.InputSignal<boolean>;
    private appStateService;
    private appStateHelperService;
    private floatingContainerService;
    private authService;
    private notificationService;
    private router;
    isSwitchingEntity: _angular_core.WritableSignal<boolean>;
    ngOnInit(): void;
    /**
     * Handle entity click event from org structure
     */
    onEntityClick(entity: CoreSystemEntityListResponse): void;
    /**
     * Handle entity select event from org structure (for switching or selection)
     * If selectionMode is true, calls the callback and closes container
     * Otherwise, calls the switch entity API to create new auth_logs entry
     */
    onEntitySelect(entity: CoreSystemEntityListResponse): void;
    /**
     * Handle entity view event from org structure (for viewing)
     */
    onEntityView(entity: CoreSystemEntityListResponse): void;
    /**
     * Cancel selection
     */
    onCancel(): void;
    /**
     * Close the floating container
     */
    private closeContainer;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytFloatingEntitySelectionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideLytFloatingEntitySelectionComponent, "cide-lyt-floating-entity-selection", never, { "allowSwitching": { "alias": "allowSwitching"; "required": false; "isSignal": true; }; "showActions": { "alias": "showActions"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "onSelectCallback": { "alias": "onSelectCallback"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CideLytFloatingEntitySelectionService {
    private containerService;
    constructor();
    private initializeEntitySelection;
    /**
     * Get responsive dimensions based on screen size
     */
    private getResponsiveDimensions;
    /**
     * Show entity selection in floating container
     * @param onSelect - Optional callback function that receives the selected entity (for selection mode, not switching)
     * @param title - Optional title for the container (default: 'Switch Entity')
     */
    show(onSelect?: (entity: any) => void, title?: string): Promise<string>;
    /**
     * Hide entity selection container
     */
    hide(containerId?: string): void;
    /**
     * Check if entity selection is currently visible
     */
    isVisible(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideLytFloatingEntitySelectionService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideLytFloatingEntitySelectionService>;
}

export { AppStateHelperService, AppStateService, CacheManagerService, CideLytFileManagerService, CideLytFloatingEntityRightsSharingComponent, CideLytFloatingEntityRightsSharingService, CideLytFloatingEntitySelectionComponent, CideLytFloatingEntitySelectionService, CideLytRequestService, CideLytSharedService, CideLytSharedWrapperComponent, CideLytThemeService, CideLytUserStatusService, CloudIdeLayoutComponent, CloudIdeLayoutService, ComponentContextService, CustomRouteReuseStrategy, ENVIRONMENT_CONFIG, NotificationSettingsService, RightsService, layoutControlPannelChildRoutes, layoutRoutes, processThemeVariable, setCSSVariable, themeFactory };
export type { AppState, BreadcrumbItem, CideLytSharedWrapperSetupParam, EntityRightsSharingData, NotificationSettings, TabInfo, Theme, UserStatus, UserStatusData };