cloud-ide-layout 0.0.1 → 1.0.0

package/lib/layout/request/request-wrapper/request-wrapper.component.d.ts

@@ -1,5 +1,14 @@
+import { ElementRef, QueryList, AfterViewInit } from '@angular/core';
+import { CideLytRequestService } from '../request.service';
 import * as i0 from "@angular/core";
-export declare class CideLytRequestWrapperComponent {
+export declare class CideLytRequestWrapperComponent implements AfterViewInit {
+    requestService: CideLytRequestService;
+    requestItemElements: QueryList<ElementRef>;
+    requestItems: import("@angular/core").Signal<import("../request.service").TabInfo[]>;
+    constructor(requestService: CideLytRequestService);
+    ngAfterViewInit(): void;
+    private applyAnimations;
+    applyFlickerEffect(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CideLytRequestWrapperComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CideLytRequestWrapperComponent, "cide-lyt-request-wrapper", never, {}, {}, never, never, true, never>;
 }

package/lib/layout/request/request.service.d.ts

@@ -0,0 +1,60 @@
+import { WritableSignal, Signal } from '@angular/core';
+import { ISytmLayout } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export 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;
+        };
+    };
+}
+export 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;
+    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;
+    hideRequest(): void;
+    showRequest(): void;
+    private generateId;
+    updateTabScrollPosition(tabId: string, scrollTop: number, scrollLeft: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideLytRequestService>;
+}
+export {};

package/lib/layout/request/tab-content/tab-content.component.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef, AfterViewInit, ChangeDetectorRef } from '@angular/core';
+import { Router } from '@angular/router';
+import { CideLytRequestService } from '../request.service';
+import * as i0 from "@angular/core";
+export declare class TabContentComponent implements AfterViewInit {
+    private requestService;
+    private router;
+    private cdr;
+    scrollContainerRef: ElementRef<HTMLDivElement>;
+    private currentActiveTabId;
+    private isRestoringScroll;
+    constructor(requestService: CideLytRequestService, router: Router, // Inject Router to listen for NavigationEnd
+    cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    onScroll(): void;
+    private restoreScrollPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabContentComponent, "cide-lyt-tab-content", never, {}, {}, never, never, true, never>;
+}

package/lib/layout/shared/shared-wrapper/shared-wrapper.component.d.ts

@@ -1,15 +1,14 @@
 import { OnInit } from '@angular/core';
-import { CideLytSharedService } from '../shared.service';
 import { designConfigResponseData } from 'cloud-ide-lms-model';
+import { AppStateHelperService } from '../../../services/app-state/app-state-helper.service';
 import * as i0 from "@angular/core";
 export declare class CideLytSharedWrapperComponent implements OnInit {
-    private sharedService;
     shared_wrapper_setup_param: Partial<CideLytSharedWrapperSetupParam>;
     page_data: designConfigResponseData;
-    constructor(sharedService: CideLytSharedService);
+    private sharedService;
+    private sidedrawerService;
+    protected appState: AppStateHelperService;
     ngOnInit(): void;
-    loadPageData(): void;
-    setTitle(title: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSharedWrapperComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CideLytSharedWrapperComponent, "cide-lyt-shared-wrapper", never, {}, {}, never, never, true, never>;
 }

package/lib/layout/shared/shared.service.d.ts

@@ -1,16 +1,114 @@
-import { designConfigControllerResponse, MDesignConfig } from 'cloud-ide-lms-model';
-import { HttpClient } from '@angular/common/http';
+import { designConfigControllerResponse, ISytmLayout, MDesignConfig } from 'cloud-ide-lms-model';
 import { Observable } from 'rxjs';
 import { Title } from '@angular/platform-browser';
-import { CideElementsService } from 'cloud-ide-element';
+import { CideLytSharedWrapperSetupParam } from './shared-wrapper/shared-wrapper.component';
 import * as i0 from "@angular/core";
+interface CachedPageData {
+    request: Partial<CideLytSharedWrapperSetupParam>;
+    response: designConfigControllerResponse;
+    timestamp: number;
+    ttl: number;
+}
 export declare class CideLytSharedService {
+    private pageDataCacheSignal;
+    private loadingStateSignal;
+    readonly pageDataCache: import("@angular/core").Signal<{
+        [key: string]: CachedPageData;
+    }>;
+    readonly loadingStates: import("@angular/core").Signal<{
+        [key: string]: boolean;
+    }>;
+    readonly cacheInfo: import("@angular/core").Signal<{
+        totalCached: number;
+        validCached: number;
+        expiredCached: number;
+    }>;
+    private inflightRequests;
+    private readonly DEFAULT_CACHE_TTL;
     private elementService;
     private http;
     titleService: Title;
-    constructor(elementService: CideElementsService, http: HttpClient, titleService: Title);
-    loadPageData(body: MDesignConfig): Observable<designConfigControllerResponse>;
-    setPageData(page_data_response: designConfigControllerResponse): void;
+    private sidebarService;
+    private headerService;
+    private footerService;
+    private consoleService;
+    private sidedrawerService;
+    private router;
+    private appState;
+    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;
+    /**
+     * 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;
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<CideLytSharedService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CideLytSharedService>;
 }
+export {};

package/lib/layout/sidebar/sidebar-wrapper/sidebar-wrapper.component.d.ts

@@ -1,11 +1,140 @@
+import { OnInit } from '@angular/core';
 import { menuResponseData } from 'cloud-ide-lms-model';
-import { CideLytSidebarService } from '../sidebar.service';
+import { AppStateHelperService } from '../../../services/app-state';
+import { CideLytUserStatusService, type UserStatus } from '../../../services/user-status/user-status.service';
 import * as i0 from "@angular/core";
-export declare class SidebarWrapperComponent {
-    private sidebarService;
+export declare class CideLytSidebarWrapperComponent implements OnInit {
+    sidebarSetupData: {
+        cide_lyt_sidebar_width: number;
+    };
+    isCollapsed: boolean;
+    darkMode: boolean;
+    showUserMenu: boolean;
+    showOptions: boolean;
+    showNotifications: boolean;
+    showNotificationsPanel: boolean;
+    searchText: string;
+    isExpanded: boolean;
+    searchResults: {
+        icon: string;
+        title: string;
+    }[];
+    collapsedSections: {
+        [key: string]: boolean;
+    };
+    expandedSections: {
+        [key: string]: boolean;
+    };
+    animateSections: boolean[];
+    lastScrollTop: number;
+    scrolledPast: boolean[];
     core_system_menu: menuResponseData[];
     core_system_module: menuResponseData[];
-    constructor(sidebarService: CideLytSidebarService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarWrapperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarWrapperComponent, "cide-lyt-sidebar-wrapper", never, {}, {}, never, never, true, never>;
+    activeModuleId: string;
+    hoverModuleId: string;
+    animateItems: boolean;
+    moduleLoadComplete: boolean;
+    menuLoadComplete: boolean;
+    loadingMenus: boolean;
+    get selectedModuleMenus(): menuResponseData[];
+    /**
+     * Gets the CSS classes for the user status indicator
+     * Uses the injected user status service
+     */
+    getUserStatusClass(): string;
+    /**
+     * Gets the tooltip text for the user status
+     * Uses the injected user status service
+     */
+    getUserStatusText(): string;
+    /**
+     * Sets the user status (delegates to service)
+     * @param status The new status to set
+     * @param message Optional custom status message
+     */
+    setUserStatus(status: UserStatus, message?: string): void;
+    /**
+     * Gets the current user status data
+     */
+    get currentUserStatus(): import("../../../services/user-status/user-status.service").UserStatusData;
+    /**
+     * Gets the icon for the currently active module
+     * @returns The icon name for the active module or a default icon
+     */
+    getActiveModuleIcon(): string;
+    onMenuClick(menu: menuResponseData): void;
+    /**
+     * Toggle section expand/collapse state
+     */
+    toggleSection(sectionId: string): void;
+    /**
+     * Check if section is expanded
+     */
+    isSectionExpanded(sectionId: string): boolean;
+    private sidebarService;
+    private elementRef;
+    appState: AppStateHelperService;
+    private router;
+    protected userStatusService: CideLytUserStatusService;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Load menus for a specific module
+     * @param module The module to load menus for
+     */
+    loadMenusForModule(module: menuResponseData): void;
+    toggleSidebar(): void;
+    toggleUserMenu(): void;
+    /**
+     * Sets the active menu item with animation
+     * @param moduleId The ID of the module to set as active
+     */
+    setActiveMenu(moduleId: string): void;
+    /**
+     * Sets the active menu item by index with animation
+     * @param index The index of the menu item
+     */
+    setActiveMenuByIndex(index: number): void;
+    /**
+     * Public method to set active module by ID from external components
+     * This is useful when you want to programmatically set the active module
+     * @param moduleId The ID of the module to set as active
+     * @returns boolean indicating if the module was found and set as active
+     */
+    setActiveModuleById(moduleId: string): boolean;
+    /**
+     * Public method to get the currently active module ID
+     * @returns The ID of the currently active module, or empty string if none
+     */
+    getActiveModuleId(): string;
+    /**
+     * Tracks hover state for enhanced visual feedback
+     * @param moduleId The ID of the hovered module, or empty string for none
+     */
+    onItemHover(moduleId: string): void;
+    /**
+     * Adds subtle animations when opening dropdown menus
+     * @param menuId The ID of the menu element
+     */
+    animateMenuOpen(menuId: string): void;
+    /**
+     * Updates tooltip position for more accurate placement
+     * @param event MouseEvent from hovering
+     * @param tooltip The tooltip element
+     */
+    updateTooltipPosition(event: MouseEvent, tooltipIndex: number): void;
+    toggleNotificationsPanel(): void;
+    toggleTheme(): void;
+    toggleOptions(): void;
+    /**
+     * Toggle old-style collapsed sections (for backwards compatibility)
+     */
+    toggleCollapsedSection(section: string): void;
+    isSectionCollapsed(section: string): boolean;
+    onSearch(): void;
+    onScroll(event: Event): void;
+    resetAnimations(): void;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSidebarWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideLytSidebarWrapperComponent, "cide-lyt-sidebar-wrapper", never, {}, {}, never, never, true, never>;
 }

package/lib/layout/sidebar/sidebar.service.d.ts

@@ -1,11 +1,12 @@
-import { HttpClient } from '@angular/common/http';
 import { menuControllerResponse, MMenu } from 'cloud-ide-lms-model';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class CideLytSidebarService {
+    sidebarMenueVisible: boolean;
     private http;
-    constructor(http: HttpClient);
     getSidebarMenues(body: MMenu): Observable<menuControllerResponse>;
+    hideSidebar(): void;
+    showSidebar(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSidebarService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CideLytSidebarService>;
 }

package/lib/layout/sidedrawer/cide-lyt-drawer-base.class.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { CideLytSidedrawerService } from './sidedrawer.service';
+import * as i0 from "@angular/core";
+export declare abstract class CideLytDrawerBase implements OnInit {
+    private _pageId;
+    private _themeId;
+    protected sidedrawerService: CideLytSidedrawerService;
+    ngOnInit(): void;
+    protected afterContextInit(): void;
+    setContext(pageId: string, themeId: string): void;
+    get pageId(): string | null;
+    get themeId(): string | null;
+    protected getStorageKey(suffix: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytDrawerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CideLytDrawerBase, never, never, {}, {}, never, never, false, never>;
+}

package/lib/layout/sidedrawer/drawer-theme/drawer-theme.component.d.ts

@@ -0,0 +1,71 @@
+import { OnInit } from '@angular/core';
+import { SelectOption } from 'cloud-ide-element';
+import { CideLytThemeService } from '../../../services/theme/theme.service';
+import type { ICoreSyth } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+interface ThemeColor {
+    label: string;
+    varName: string;
+    value: string;
+}
+interface TypographySetting {
+    label: string;
+    varName: string;
+    value: string;
+    type: 'number' | 'text';
+    min?: number;
+    max?: number;
+}
+type ThemeGroup = {
+    label: string;
+    items: Array<{
+        label: string;
+        varName: string;
+        value: string;
+        type: 'number' | 'text';
+        min?: number;
+        max?: number;
+    }>;
+};
+export declare class CideLytDrawerThemeComponent implements OnInit {
+    private themeService;
+    private platformId;
+    private readonly appState;
+    presetThemes: {
+        value: string;
+        label: string;
+        theme: ICoreSyth;
+    }[];
+    selectedTheme: string;
+    isLoadingThemes: boolean;
+    themeLoadError: string;
+    mergedTheme: {
+        [key: string]: string;
+    };
+    isRTL: boolean;
+    originalThemeGroupValues: ThemeGroup[];
+    originalApiThemeValues: {
+        [key: string]: string;
+    };
+    themeGroups: ThemeGroup[];
+    constructor(themeService: CideLytThemeService, platformId: object);
+    ngOnInit(): void;
+    loadAndApplyUserTheme(): void;
+    updateVar(varName: string, value: string): void;
+    onThemeChange(event: SelectOption): void;
+    onReset(): void;
+    onSave(): void;
+    hasUnsavedChanges(): boolean;
+    /**
+     * Check if current values differ from the original API values
+     * This is useful for determining if reset should be enabled
+     */
+    hasChangesFromOriginal(): boolean;
+    onColorChange(event: Event, color: ThemeColor): void;
+    onTypographyChange(event: Event, setting: TypographySetting): void;
+    onLayoutChange(event: Event, setting: TypographySetting): void;
+    onDirectionToggle(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytDrawerThemeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideLytDrawerThemeComponent, "cide-lyt-drawer-theme", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/layout/sidedrawer/sidedrawer-notes/sidedrawer-notes.component.d.ts

@@ -0,0 +1,48 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ICoreSypn } from 'cloud-ide-lms-model';
+import { CideLytDrawerBase } from '../cide-lyt-drawer-base.class';
+import * as i0 from "@angular/core";
+export interface NewNoteModel {
+    title: string;
+    description: string;
+    isPageSpecific: boolean;
+    isUserSpecific: boolean;
+    isEntitySpecific: boolean;
+    isThemeSpecific: boolean;
+}
+export interface NotesComponentState {
+    newNoteModel: NewNoteModel;
+    isFormVisible: boolean;
+    scrollTop: number;
+}
+export declare class CideLytSidedrawerNotesComponent extends CideLytDrawerBase implements OnInit {
+    private notesSignal;
+    notes: import("@angular/core").Signal<ICoreSypn[]>;
+    isFormVisible: boolean;
+    isEditing: boolean;
+    editingNoteId: string | null;
+    hoveredNoteIndex: number | null;
+    noteForm: FormGroup;
+    private notesService;
+    private fb;
+    private appState;
+    ngOnInit(): void;
+    protected afterContextInit(): void;
+    private initForm;
+    showAddForm(): void;
+    hideAddForm(): void;
+    startEdit(note: ICoreSypn): void;
+    cancelEdit(): void;
+    onNoteHover(index: number): void;
+    onNoteLeave(): void;
+    onSubmit(): void;
+    private resetForm;
+    getState(): {
+        newNoteModel: any;
+        isFormVisible: boolean;
+    };
+    setState(state: NotesComponentState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSidedrawerNotesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideLytSidedrawerNotesComponent, "cide-lyt-sidedrawer-notes", never, {}, {}, never, never, true, never>;
+}

package/lib/layout/sidedrawer/sidedrawer-notes/sidedrawer-notes.service.d.ts

@@ -0,0 +1,13 @@
+import { ICoreSypn } from 'cloud-ide-lms-model';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class CideLytDrawerNotesService {
+    private http;
+    constructor();
+    getNotes(): Observable<ICoreSypn[]>;
+    addNote(note: ICoreSypn): Observable<unknown>;
+    updateNote(note: ICoreSypn): Observable<unknown>;
+    deleteNote(noteId: string): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytDrawerNotesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideLytDrawerNotesService>;
+}

package/lib/layout/sidedrawer/sidedrawer-wrapper/sidedrawer-wrapper.component.d.ts

@@ -1,5 +1,30 @@
+import { OnInit, ViewContainerRef } from '@angular/core';
+import { CideLytSidedrawerService, SidedrawerItem } from '../sidedrawer.service';
 import * as i0 from "@angular/core";
-export declare class SidedrawerWrapperComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SidedrawerWrapperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SidedrawerWrapperComponent, "cide-lyt-sidedrawer-wrapper", never, {}, {}, never, never, true, never>;
+export declare class CideLytSidedrawerWrapperComponent implements OnInit {
+    sidedrawerSetupData: {
+        cide_lyt_sidedrawer_width: number;
+    };
+    get drawerItems(): import("@angular/core").Signal<SidedrawerItem[]>;
+    get notesVisible(): import("@angular/core").Signal<boolean>;
+    isExpanded: boolean;
+    get shouldShowSidedrawer(): import("@angular/core").Signal<boolean>;
+    notesContainer: ViewContainerRef;
+    private currentComponentRef;
+    private componentMap;
+    private currentTabId;
+    private currentActiveComponent;
+    sidedrawerService: CideLytSidedrawerService;
+    private requestService;
+    private tabStateService;
+    constructor();
+    ngOnInit(): void;
+    loadComponent(configFor: string | null): Promise<void>;
+    private clearComponent;
+    private saveSidedrawerState;
+    private setComponentContext;
+    private getNotesContext;
+    onItemClick(item: SidedrawerItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSidedrawerWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideLytSidedrawerWrapperComponent, "cide-lyt-sidedrawer-wrapper", never, {}, {}, never, never, true, never>;
 }

package/lib/layout/sidedrawer/sidedrawer.service.d.ts

@@ -0,0 +1,30 @@
+import { ISytmLayout } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export interface SidedrawerItem {
+    status: boolean;
+    configFor: string;
+    title: string;
+    icon: string;
+    description: string;
+    isActive: boolean;
+}
+export declare class CideLytSidedrawerService {
+    sidedrawerVisible: boolean;
+    private drawerItemsSignal;
+    drawerItems: import("@angular/core").Signal<SidedrawerItem[]>;
+    private notesVisibleSignal;
+    notesVisible: import("@angular/core").Signal<boolean>;
+    private activeComponentSignal;
+    activeComponent: import("@angular/core").Signal<string | null>;
+    private _pageId;
+    private _themeId;
+    setContext(pageId: string, themeId: string): void;
+    get pageId(): string | null;
+    get themeId(): string | null;
+    hideSidedrawer(): void;
+    showSidedrawer(): void;
+    updateDrawerItems(layout: ISytmLayout | undefined): void;
+    setActiveComponent(configFor: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytSidedrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideLytSidedrawerService>;
+}