@gravionlabs/helix-shell 22.1.2 → 22.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/fesm2022/gravionlabs-helix-shell.mjs +5302 -1704
  2. package/fesm2022/gravionlabs-helix-shell.mjs.map +1 -1
  3. package/package.json +1 -1
  4. package/types/gravionlabs-helix-shell.d.ts +1431 -909
package/types/gravionlabs-helix-shell.d.ts CHANGED
@@ -1,97 +1,171 @@
1
- import * as _angular_core from '@angular/core';
2
- import { InjectionToken, Type, OnInit, OnDestroy, ElementRef, AfterViewInit } from '@angular/core';
3
- import { AbstractControl, ControlValueAccessor } from '@angular/forms';
4
- import { ActivatedRoute, ActivatedRouteSnapshot, Route, CanActivateFn, Routes, Router } from '@angular/router';
5
- import { MenuItem } from '@gravionlabs/helix-core/api';
6
- import * as _ngrx_signals from '@ngrx/signals';
7
- import * as _gravionlabs_helix_shell from '@gravionlabs/helix-shell';
8
- import { HelixConfig } from '@gravionlabs/helix-core/config';
9
- import * as _angular_platform_browser from '@angular/platform-browser';
10
-
11
- declare class HelixFormField {
12
- readonly label: _angular_core.InputSignal<string | undefined>;
13
- readonly control: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
14
- readonly hint: _angular_core.InputSignal<string | undefined>;
15
- readonly error: _angular_core.InputSignal<string | null>;
16
- readonly showLabel: _angular_core.InputSignal<boolean>;
17
- readonly showHint: _angular_core.InputSignal<boolean>;
18
- readonly activeError: _angular_core.Signal<string | null>;
19
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFormField, never>;
20
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixFormField, "helix-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showHint": { "alias": "showHint"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
21
- }
22
-
23
- declare class HelixSelect implements ControlValueAccessor {
24
- readonly options: _angular_core.InputSignal<any[]>;
25
- readonly optionLabel: _angular_core.InputSignal<string>;
26
- readonly optionValue: _angular_core.InputSignal<string>;
27
- readonly placeholder: _angular_core.InputSignal<string>;
28
- readonly disabled: _angular_core.InputSignal<boolean>;
29
- readonly value: _angular_core.WritableSignal<any>;
30
- protected onChange: (value: any) => void;
31
- protected onTouched: () => void;
32
- readonly processedOptions: _angular_core.Signal<{
33
- label: any;
34
- value: any;
35
- }[]>;
36
- writeValue(value: any): void;
37
- registerOnChange(fn: any): void;
38
- registerOnTouched(fn: any): void;
39
- setDisabledState?(isDisabled: boolean): void;
40
- onSelectChange(event: Event): void;
41
- protected isSelected(optValue: any): boolean;
42
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixSelect, never>;
43
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixSelect, "helix-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
44
- }
45
-
1
+ import { AbstractControl, ControlValueAccessor } from "@angular/forms";
2
+ import * as i0 from "@angular/core";
3
+ import { AfterViewInit, ElementRef, InjectionToken, OnDestroy, OnInit, Type } from "@angular/core";
4
+ import { ActivatedRoute, ActivatedRouteSnapshot, CanActivateFn, Route, Router, Routes } from "@angular/router";
5
+ import { MenuItem } from "@gravionlabs/helix-core/api";
6
+ import { HelixConfig } from "@gravionlabs/helix-core/config";
7
+ export declare class HelixFormField {
8
+ readonly label: import("@angular/core").InputSignal<string | undefined>;
9
+ readonly control: import("@angular/core").InputSignal<AbstractControl<any, any, any> | null>;
10
+ readonly hint: import("@angular/core").InputSignal<string | undefined>;
11
+ readonly error: import("@angular/core").InputSignal<string | null>;
12
+ readonly showLabel: import("@angular/core").InputSignal<boolean>;
13
+ readonly showHint: import("@angular/core").InputSignal<boolean>;
14
+ readonly activeError: import("@angular/core").Signal<string | null>;
15
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixFormField, never>;
16
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixFormField, "helix-form-field", never, {
17
+ "label": {
18
+ "alias": "label";
19
+ "required": false;
20
+ "isSignal": true;
21
+ };
22
+ "control": {
23
+ "alias": "control";
24
+ "required": false;
25
+ "isSignal": true;
26
+ };
27
+ "hint": {
28
+ "alias": "hint";
29
+ "required": false;
30
+ "isSignal": true;
31
+ };
32
+ "error": {
33
+ "alias": "error";
34
+ "required": false;
35
+ "isSignal": true;
36
+ };
37
+ "showLabel": {
38
+ "alias": "showLabel";
39
+ "required": false;
40
+ "isSignal": true;
41
+ };
42
+ "showHint": {
43
+ "alias": "showHint";
44
+ "required": false;
45
+ "isSignal": true;
46
+ };
47
+ }, {}, never, ["*"], true, never>;
48
+ }
49
+ export declare class HelixSelect implements ControlValueAccessor {
50
+ readonly options: import("@angular/core").InputSignal<any[]>;
51
+ readonly optionLabel: import("@angular/core").InputSignal<string>;
52
+ readonly optionValue: import("@angular/core").InputSignal<string>;
53
+ readonly placeholder: import("@angular/core").InputSignal<string>;
54
+ readonly disabled: import("@angular/core").InputSignal<boolean>;
55
+ readonly value: import("@angular/core").WritableSignal<any>;
56
+ protected onChange: (value: any) => void;
57
+ protected onTouched: () => void;
58
+ readonly processedOptions: import("@angular/core").Signal<{
59
+ label: any;
60
+ value: any;
61
+ }[]>;
62
+ writeValue(value: any): void;
63
+ registerOnChange(fn: any): void;
64
+ registerOnTouched(fn: any): void;
65
+ setDisabledState?(isDisabled: boolean): void;
66
+ onSelectChange(event: Event): void;
67
+ protected isSelected(optValue: any): boolean;
68
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixSelect, never>;
69
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixSelect, "helix-select", never, {
70
+ "options": {
71
+ "alias": "options";
72
+ "required": false;
73
+ "isSignal": true;
74
+ };
75
+ "optionLabel": {
76
+ "alias": "optionLabel";
77
+ "required": false;
78
+ "isSignal": true;
79
+ };
80
+ "optionValue": {
81
+ "alias": "optionValue";
82
+ "required": false;
83
+ "isSignal": true;
84
+ };
85
+ "placeholder": {
86
+ "alias": "placeholder";
87
+ "required": false;
88
+ "isSignal": true;
89
+ };
90
+ "disabled": {
91
+ "alias": "disabled";
92
+ "required": false;
93
+ "isSignal": true;
94
+ };
95
+ }, {}, never, never, true, never>;
96
+ }
46
97
  interface HelixBreadcrumb {
47
- label: string;
48
- route?: string;
98
+ label: string;
99
+ route?: string;
49
100
  }
50
- declare const HELIX_BREADCRUMB: InjectionToken<HelixBreadcrumb[]>;
51
-
52
- declare function helixBreadcrumbsFromRoutes(route: ActivatedRoute): MenuItem[];
53
-
101
+ export declare const HELIX_BREADCRUMB: InjectionToken<HelixBreadcrumb[]>;
102
+ export declare function helixBreadcrumbsFromRoutes(route: ActivatedRoute): MenuItem[];
54
103
  type BadgeSeverity = 'info' | 'warn' | 'error' | 'success';
55
- declare class HelixBadge {
56
- severity: _angular_core.InputSignal<BadgeSeverity>;
57
- label: _angular_core.InputSignal<string | undefined>;
58
- icon: _angular_core.InputSignal<string | undefined>;
59
- size: _angular_core.InputSignal<"sm" | "md">;
60
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixBadge, never>;
61
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixBadge, "helix-badge", never, { "severity": { "alias": "severity"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
62
- }
63
-
104
+ export declare class HelixBadge {
105
+ severity: import("@angular/core").InputSignal<BadgeSeverity>;
106
+ label: import("@angular/core").InputSignal<string | undefined>;
107
+ icon: import("@angular/core").InputSignal<string | undefined>;
108
+ size: import("@angular/core").InputSignal<"sm" | "md">;
109
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixBadge, never>;
110
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixBadge, "helix-badge", never, {
111
+ "severity": {
112
+ "alias": "severity";
113
+ "required": true;
114
+ "isSignal": true;
115
+ };
116
+ "label": {
117
+ "alias": "label";
118
+ "required": false;
119
+ "isSignal": true;
120
+ };
121
+ "icon": {
122
+ "alias": "icon";
123
+ "required": false;
124
+ "isSignal": true;
125
+ };
126
+ "size": {
127
+ "alias": "size";
128
+ "required": false;
129
+ "isSignal": true;
130
+ };
131
+ }, {}, never, never, true, never>;
132
+ }
64
133
  type Environment = 'development' | 'testing' | 'staging' | 'production';
65
- declare class HelixEnvironmentBadge {
66
- environment: _angular_core.InputSignal<Environment>;
67
- protected mapped: _angular_core.Signal<{
68
- severity: BadgeSeverity;
69
- icon: string;
70
- label: string;
71
- }>;
72
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixEnvironmentBadge, never>;
73
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixEnvironmentBadge, "helix-environment-badge", never, { "environment": { "alias": "environment"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
74
- }
75
-
134
+ export declare class HelixEnvironmentBadge {
135
+ environment: import("@angular/core").InputSignal<Environment>;
136
+ protected mapped: import("@angular/core").Signal<{
137
+ severity: BadgeSeverity;
138
+ icon: string;
139
+ label: string;
140
+ }>;
141
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixEnvironmentBadge, never>;
142
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixEnvironmentBadge, "helix-environment-badge", never, {
143
+ "environment": {
144
+ "alias": "environment";
145
+ "required": true;
146
+ "isSignal": true;
147
+ };
148
+ }, {}, never, never, true, never>;
149
+ }
76
150
  /**
77
151
  * Extends Helix's MenuItem with Angular routing properties.
78
152
  * Allows a single array to define both the sidebar menu and the router configuration.
79
153
  */
80
154
  interface HelixRouteMenuItem extends MenuItem {
81
- /** Angular route path segment (relative to the parent route). */
82
- path?: string;
83
- /** Breadcrumb label or resolver for auto-generated breadcrumbs. */
84
- breadcrumb?: string | ((route: ActivatedRouteSnapshot) => string);
85
- /** Component to render for this route. */
86
- component?: Type<unknown>;
87
- /** Lazy-loaded children module or routes. */
88
- loadChildren?: Route['loadChildren'];
89
- /** Route guards. */
90
- canActivate?: CanActivateFn[];
91
- /** Additional route data (merged with the auto-injected menu data). */
92
- data?: Record<string, unknown>;
93
- /** Typed override of MenuItem.items — supports nested HelixRouteMenuItem entries. */
94
- items?: HelixRouteMenuItem[];
155
+ /** Angular route path segment (relative to the parent route). */
156
+ path?: string;
157
+ /** Breadcrumb label or resolver for auto-generated breadcrumbs. */
158
+ breadcrumb?: string | ((route: ActivatedRouteSnapshot) => string);
159
+ /** Component to render for this route. */
160
+ component?: Type<unknown>;
161
+ /** Lazy-loaded children module or routes. */
162
+ loadChildren?: Route['loadChildren'];
163
+ /** Route guards. */
164
+ canActivate?: CanActivateFn[];
165
+ /** Additional route data (merged with the auto-injected menu data). */
166
+ data?: Record<string, unknown>;
167
+ /** Typed override of MenuItem.items — supports nested HelixRouteMenuItem entries. */
168
+ items?: HelixRouteMenuItem[];
95
169
  }
96
170
  /**
97
171
  * Recursively copies a HelixRouteMenuItem tree and auto-populates `routerLink`
@@ -105,7 +179,7 @@ interface HelixRouteMenuItem extends MenuItem {
105
179
  * helixMenuLinksFrom(UIKIT_ITEMS, '/uikit')
106
180
  * // → { path: 'formlayout', label: '...', icon: '...', routerLink: ['/uikit/formlayout'] }
107
181
  */
108
- declare function helixMenuLinksFrom(items: HelixRouteMenuItem[], basePath: string): HelixRouteMenuItem[];
182
+ export declare function helixMenuLinksFrom(items: HelixRouteMenuItem[], basePath: string): HelixRouteMenuItem[];
109
183
  /**
110
184
  * Converts a HelixRouteMenuItem tree into Angular Routes.
111
185
  *
@@ -115,140 +189,335 @@ declare function helixMenuLinksFrom(items: HelixRouteMenuItem[], basePath: strin
115
189
  * - Items with only `routerLink` (e.g. links into lazy-loaded sub-modules) are
116
190
  * skipped — they do not need a route entry here.
117
191
  */
118
- declare function helixRoutesFrom(items: HelixRouteMenuItem[]): Routes;
119
-
192
+ export declare function helixRoutesFrom(items: HelixRouteMenuItem[]): Routes;
193
+ /**
194
+ * A group of nav-rail items under an optional uppercase section label.
195
+ * Reuses HelixRouteMenuItem for items so existing routerLink/path-driven
196
+ * active state, breadcrumbs, and route generation keep working unchanged.
197
+ */
198
+ interface HelixNavGroup {
199
+ /** Uppercase section label shown above the items. Omit for an unlabeled group. */
200
+ section?: string;
201
+ /** Icon of the section. In the collapsed rail the section becomes one icon with a flyout of its items. */
202
+ icon?: string;
203
+ items: HelixRouteMenuItem[];
204
+ }
205
+ /** How a flat menu is mapped onto the nav rail. */
206
+ type HelixNavStyle = 'sections' | 'tree';
207
+ /**
208
+ * Adapts a flat HelixRouteMenuItem tree (as used by HelixAppLayout's `menu`
209
+ * input) into HelixNavGroup[].
210
+ *
211
+ * - `'sections'` (default): every top-level item with children becomes an
212
+ * uppercase section whose children are listed directly; consecutive
213
+ * top-level items without children form one unlabeled group. Deeper levels
214
+ * still expand inline.
215
+ * - `'tree'`: the whole menu is one unlabeled group, so each top-level item
216
+ * with children renders as an expandable HelixNavRailItem.
217
+ */
218
+ export declare function helixNavGroupsFromMenu(items: HelixRouteMenuItem[], style?: HelixNavStyle): HelixNavGroup[];
120
219
  type HelixStatusBarTone = 'staging' | 'production' | 'success' | 'danger' | 'neutral';
121
220
  interface HelixStatusBarVersion {
122
- label: string;
123
- value: string;
221
+ label: string;
222
+ value: string;
124
223
  }
125
-
126
224
  interface AlertItem {
127
- id: string;
128
- label: string;
129
- severity: string;
130
- route?: string;
225
+ id: string;
226
+ label: string;
227
+ severity: string;
228
+ route?: string;
131
229
  }
132
- declare class HelixAlertAction {
133
- count: _angular_core.InputSignal<number>;
134
- alerts: _angular_core.InputSignal<AlertItem[] | undefined>;
135
- protected open: _angular_core.WritableSignal<boolean>;
136
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixAlertAction, never>;
137
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixAlertAction, "helix-alert-action", never, { "count": { "alias": "count"; "required": true; "isSignal": true; }; "alerts": { "alias": "alerts"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
230
+ export declare class HelixAlertAction {
231
+ count: import("@angular/core").InputSignal<number>;
232
+ alerts: import("@angular/core").InputSignal<AlertItem[] | undefined>;
233
+ protected open: import("@angular/core").WritableSignal<boolean>;
234
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixAlertAction, never>;
235
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixAlertAction, "helix-alert-action", never, {
236
+ "count": {
237
+ "alias": "count";
238
+ "required": true;
239
+ "isSignal": true;
240
+ };
241
+ "alerts": {
242
+ "alias": "alerts";
243
+ "required": false;
244
+ "isSignal": true;
245
+ };
246
+ }, {}, never, never, true, never>;
138
247
  }
139
-
140
248
  interface HelixTopbarAction {
141
- icon: string;
142
- label: string;
143
- command?: () => void;
249
+ icon: string;
250
+ label: string;
251
+ command?: () => void;
144
252
  }
145
253
  type HelixTopbarItemType = 'darkmode' | 'configurator' | 'mobile' | 'alert' | 'action';
146
254
  interface HelixTopbarItem {
147
- type: HelixTopbarItemType;
148
- icon?: string;
149
- label?: string;
150
- badgeCount?: number;
151
- alerts?: AlertItem[];
152
- command?: () => void;
153
- }
154
-
155
- declare class HelixAppLayout {
156
- appTitle: _angular_core.InputSignal<string>;
157
- environment: _angular_core.InputSignal<Environment | undefined>;
158
- /** Topbar items. When provided, overrides the default darkmode / configurator / mobile items. */
159
- topbarItems: _angular_core.InputSignal<HelixTopbarItem[] | undefined>;
160
- /** Topbar actions rendered in the right-side dropdown. */
161
- topbarActions: _angular_core.InputSignal<HelixTopbarAction[] | undefined>;
162
- /**
163
- * Nav-rail brand icon: inline SVG (`<svg>…</svg>`) or a URL to an SVG file.
164
- * Falls back to the default hardcoded icon when not provided.
165
- */
166
- brandIcon: _angular_core.InputSignal<string | undefined>;
167
- /** Status bar inputs */
168
- statusBarEnvironment: _angular_core.InputSignal<string | undefined>;
169
- statusBarNote: _angular_core.InputSignal<string | undefined>;
170
- statusBarTone: _angular_core.InputSignal<HelixStatusBarTone>;
171
- statusBarVersions: _angular_core.InputSignal<HelixStatusBarVersion[]>;
172
- statusBarBrand: _angular_core.InputSignal<string>;
173
- /**
174
- * Menu model. When provided, overrides route data.
175
- * Also auto-populated from ActivatedRoute.data['menu'] when used as a route component.
176
- */
177
- menu: _angular_core.InputSignal<HelixRouteMenuItem[]>;
178
- private static readonly DEFAULT_TOP_ACTIONS;
179
- store: {
180
- preset: _angular_core.Signal<string>;
181
- primary: _angular_core.Signal<string>;
182
- surface: _angular_core.Signal<string | null | undefined>;
183
- darkTheme: _angular_core.Signal<boolean>;
184
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
185
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
186
- overlayMenuActive: _angular_core.Signal<boolean>;
187
- configSidebarVisible: _angular_core.Signal<boolean>;
188
- mobileMenuActive: _angular_core.Signal<boolean>;
189
- menuHoverActive: _angular_core.Signal<boolean>;
190
- activePath: _angular_core.Signal<string | null>;
191
- sidebarCollapsed: _angular_core.Signal<boolean>;
192
- expandedRoot: _angular_core.Signal<string | null>;
193
- isDarkTheme: _angular_core.Signal<boolean>;
194
- isOverlay: _angular_core.Signal<boolean>;
195
- isStatic: _angular_core.Signal<boolean>;
196
- isSidebarActive: _angular_core.Signal<boolean>;
197
- isCollapsed: _angular_core.Signal<boolean>;
198
- toggleDarkMode: () => void;
199
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
200
- showConfigSidebar: () => void;
201
- hideConfigSidebar: () => void;
202
- onMenuToggle: () => void;
203
- closeMobileMenu: () => void;
204
- setActivePath: (activePath: string | null) => void;
205
- setExpandedRoot: (key: string | null) => void;
206
- toggleSidebar: () => void;
207
- setMenuHoverActive: (menuHoverActive: boolean) => void;
208
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
209
- setPreset: (preset: string) => void;
210
- setPrimary: (primary: string) => void;
211
- setSurface: (surface: string | null) => void;
212
- isDesktop: () => boolean;
213
- reset: () => void;
214
- } & _ngrx_signals.StateSource<{
215
- preset: string;
216
- primary: string;
217
- surface: string | undefined | null;
218
- darkTheme: boolean;
219
- menuMode: _gravionlabs_helix_shell.MenuMode;
220
- staticMenuDesktopInactive: boolean;
221
- overlayMenuActive: boolean;
222
- configSidebarVisible: boolean;
223
- mobileMenuActive: boolean;
224
- menuHoverActive: boolean;
225
- activePath: string | null;
226
- sidebarCollapsed: boolean;
227
- expandedRoot: string | null;
228
- }>;
229
- private activatedRoute;
230
- /** Resolved menu: input takes priority, then route data, then empty. */
231
- protected effectiveMenu: _angular_core.Signal<MenuItem[]>;
232
- protected effectiveNavGroups: _angular_core.Signal<_gravionlabs_helix_shell.HelixNavGroup[]>;
233
- protected effectiveEnvironment: _angular_core.Signal<Environment | undefined>;
234
- protected effectiveItems: _angular_core.Signal<HelixTopbarItem[]>;
235
- protected effectiveTopbarActions: _angular_core.Signal<HelixTopbarAction[]>;
236
- constructor();
237
- containerClass: _angular_core.Signal<{
238
- 'layout-overlay': boolean;
239
- 'layout-static': boolean;
240
- 'layout-static-inactive': boolean;
241
- 'layout-overlay-active': boolean;
242
- 'layout-mobile-active': boolean;
243
- 'layout-sidebar-collapsed': boolean;
244
- }>;
245
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixAppLayout, never>;
246
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixAppLayout, "helix-app-layout", never, { "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "environment": { "alias": "environment"; "required": false; "isSignal": true; }; "topbarItems": { "alias": "topbarItems"; "required": false; "isSignal": true; }; "topbarActions": { "alias": "topbarActions"; "required": false; "isSignal": true; }; "brandIcon": { "alias": "brandIcon"; "required": false; "isSignal": true; }; "statusBarEnvironment": { "alias": "statusBarEnvironment"; "required": false; "isSignal": true; }; "statusBarNote": { "alias": "statusBarNote"; "required": false; "isSignal": true; }; "statusBarTone": { "alias": "statusBarTone"; "required": false; "isSignal": true; }; "statusBarVersions": { "alias": "statusBarVersions"; "required": false; "isSignal": true; }; "statusBarBrand": { "alias": "statusBarBrand"; "required": false; "isSignal": true; }; "menu": { "alias": "menu"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
247
- }
248
-
255
+ type: HelixTopbarItemType;
256
+ icon?: string;
257
+ label?: string;
258
+ badgeCount?: number;
259
+ alerts?: AlertItem[];
260
+ command?: () => void;
261
+ }
262
+ export declare class HelixAppLayout {
263
+ appTitle: import("@angular/core").InputSignal<string>;
264
+ environment: import("@angular/core").InputSignal<Environment | undefined>;
265
+ /** Topbar items. When provided, overrides the default darkmode / configurator / mobile items. */
266
+ topbarItems: import("@angular/core").InputSignal<HelixTopbarItem[] | undefined>;
267
+ /** Topbar actions rendered in the right-side dropdown. */
268
+ topbarActions: import("@angular/core").InputSignal<HelixTopbarAction[] | undefined>;
269
+ /**
270
+ * Nav-rail brand icon: inline SVG (`<svg>…</svg>`) or a URL to an SVG file.
271
+ * Falls back to the default hardcoded icon when not provided.
272
+ */
273
+ brandIcon: import("@angular/core").InputSignal<string | undefined>;
274
+ /** Status bar inputs */
275
+ statusBarEnvironment: import("@angular/core").InputSignal<string | undefined>;
276
+ statusBarNote: import("@angular/core").InputSignal<string | undefined>;
277
+ statusBarTone: import("@angular/core").InputSignal<HelixStatusBarTone>;
278
+ statusBarVersions: import("@angular/core").InputSignal<HelixStatusBarVersion[]>;
279
+ statusBarBrand: import("@angular/core").InputSignal<string>;
280
+ /**
281
+ * Menu model. When provided, overrides route data.
282
+ * Also auto-populated from ActivatedRoute.data['menu'] when used as a route component.
283
+ */
284
+ menu: import("@angular/core").InputSignal<HelixRouteMenuItem[]>;
285
+ /**
286
+ * Nav rail style. `'sections'` (default) renders top-level items with children as
287
+ * always-open section headings; `'tree'` keeps them as expandable folders.
288
+ */
289
+ navStyle: import("@angular/core").InputSignal<HelixNavStyle>;
290
+ /** Explicit nav groups. When provided, they win over the mapping of `menu`. */
291
+ navGroups: import("@angular/core").InputSignal<HelixNavGroup[] | undefined>;
292
+ private static readonly DEFAULT_TOP_ACTIONS;
293
+ store: {
294
+ preset: import("@angular/core").Signal<string>;
295
+ primary: import("@angular/core").Signal<string>;
296
+ surface: import("@angular/core").Signal<string | null | undefined>;
297
+ darkTheme: import("@angular/core").Signal<boolean>;
298
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
299
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
300
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
301
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
302
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
303
+ menuHoverActive: import("@angular/core").Signal<boolean>;
304
+ activePath: import("@angular/core").Signal<string | null>;
305
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
306
+ desktop: import("@angular/core").Signal<boolean>;
307
+ expandedKeys: import("@angular/core").Signal<string[]>;
308
+ isDarkTheme: import("@angular/core").Signal<boolean>;
309
+ isOverlay: import("@angular/core").Signal<boolean>;
310
+ isStatic: import("@angular/core").Signal<boolean>;
311
+ isSidebarActive: import("@angular/core").Signal<boolean>;
312
+ isCollapsed: import("@angular/core").Signal<boolean>;
313
+ toggleDarkMode: () => void;
314
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
315
+ showConfigSidebar: () => void;
316
+ hideConfigSidebar: () => void;
317
+ onMenuToggle: () => void;
318
+ closeMobileMenu: () => void;
319
+ setActivePath: (activePath: string | null) => void;
320
+ setExpanded: (key: string, expanded: boolean) => void;
321
+ toggleSidebar: () => void;
322
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
323
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
324
+ setPreset: (preset: string) => void;
325
+ setPrimary: (primary: string) => void;
326
+ setSurface: (surface: string | null) => void;
327
+ isDesktop: () => boolean;
328
+ setDesktop: (desktop: boolean) => void;
329
+ reset: () => void;
330
+ } & import("@ngrx/signals").StateSource<{
331
+ preset: string;
332
+ primary: string;
333
+ surface: string | undefined | null;
334
+ darkTheme: boolean;
335
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
336
+ staticMenuDesktopInactive: boolean;
337
+ overlayMenuActive: boolean;
338
+ configSidebarVisible: boolean;
339
+ mobileMenuActive: boolean;
340
+ menuHoverActive: boolean;
341
+ activePath: string | null;
342
+ sidebarCollapsed: boolean;
343
+ desktop: boolean;
344
+ expandedKeys: string[];
345
+ }>;
346
+ private activatedRoute;
347
+ /** Resolved menu: input takes priority, then route data, then empty. */
348
+ protected effectiveMenu: import("@angular/core").Signal<MenuItem[]>;
349
+ protected effectiveNavGroups: import("@angular/core").Signal<HelixNavGroup[]>;
350
+ protected effectiveEnvironment: import("@angular/core").Signal<Environment | undefined>;
351
+ protected effectiveItems: import("@angular/core").Signal<HelixTopbarItem[]>;
352
+ protected effectiveTopbarActions: import("@angular/core").Signal<HelixTopbarAction[]>;
353
+ constructor();
354
+ containerClass: import("@angular/core").Signal<{
355
+ 'layout-overlay': boolean;
356
+ 'layout-static': boolean;
357
+ 'layout-static-inactive': boolean;
358
+ 'layout-overlay-active': boolean;
359
+ 'layout-mobile-active': boolean;
360
+ 'layout-sidebar-collapsed': boolean;
361
+ }>;
362
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixAppLayout, never>;
363
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixAppLayout, "helix-app-layout", never, {
364
+ "appTitle": {
365
+ "alias": "appTitle";
366
+ "required": false;
367
+ "isSignal": true;
368
+ };
369
+ "environment": {
370
+ "alias": "environment";
371
+ "required": false;
372
+ "isSignal": true;
373
+ };
374
+ "topbarItems": {
375
+ "alias": "topbarItems";
376
+ "required": false;
377
+ "isSignal": true;
378
+ };
379
+ "topbarActions": {
380
+ "alias": "topbarActions";
381
+ "required": false;
382
+ "isSignal": true;
383
+ };
384
+ "brandIcon": {
385
+ "alias": "brandIcon";
386
+ "required": false;
387
+ "isSignal": true;
388
+ };
389
+ "statusBarEnvironment": {
390
+ "alias": "statusBarEnvironment";
391
+ "required": false;
392
+ "isSignal": true;
393
+ };
394
+ "statusBarNote": {
395
+ "alias": "statusBarNote";
396
+ "required": false;
397
+ "isSignal": true;
398
+ };
399
+ "statusBarTone": {
400
+ "alias": "statusBarTone";
401
+ "required": false;
402
+ "isSignal": true;
403
+ };
404
+ "statusBarVersions": {
405
+ "alias": "statusBarVersions";
406
+ "required": false;
407
+ "isSignal": true;
408
+ };
409
+ "statusBarBrand": {
410
+ "alias": "statusBarBrand";
411
+ "required": false;
412
+ "isSignal": true;
413
+ };
414
+ "menu": {
415
+ "alias": "menu";
416
+ "required": false;
417
+ "isSignal": true;
418
+ };
419
+ "navStyle": {
420
+ "alias": "navStyle";
421
+ "required": false;
422
+ "isSignal": true;
423
+ };
424
+ "navGroups": {
425
+ "alias": "navGroups";
426
+ "required": false;
427
+ "isSignal": true;
428
+ };
429
+ }, {}, never, never, true, never>;
430
+ }
249
431
  declare type SurfacesType = {
250
- name?: string;
251
- palette?: {
432
+ name?: string;
433
+ palette?: {
434
+ 0?: string;
435
+ 50?: string;
436
+ 100?: string;
437
+ 200?: string;
438
+ 300?: string;
439
+ 400?: string;
440
+ 500?: string;
441
+ 600?: string;
442
+ 700?: string;
443
+ 800?: string;
444
+ 900?: string;
445
+ 950?: string;
446
+ };
447
+ };
448
+ export declare class HelixConfigurator implements OnInit {
449
+ router: Router;
450
+ primeng: HelixConfig;
451
+ store: {
452
+ preset: import("@angular/core").Signal<string>;
453
+ primary: import("@angular/core").Signal<string>;
454
+ surface: import("@angular/core").Signal<string | null | undefined>;
455
+ darkTheme: import("@angular/core").Signal<boolean>;
456
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
457
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
458
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
459
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
460
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
461
+ menuHoverActive: import("@angular/core").Signal<boolean>;
462
+ activePath: import("@angular/core").Signal<string | null>;
463
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
464
+ desktop: import("@angular/core").Signal<boolean>;
465
+ expandedKeys: import("@angular/core").Signal<string[]>;
466
+ isDarkTheme: import("@angular/core").Signal<boolean>;
467
+ isOverlay: import("@angular/core").Signal<boolean>;
468
+ isStatic: import("@angular/core").Signal<boolean>;
469
+ isSidebarActive: import("@angular/core").Signal<boolean>;
470
+ isCollapsed: import("@angular/core").Signal<boolean>;
471
+ toggleDarkMode: () => void;
472
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
473
+ showConfigSidebar: () => void;
474
+ hideConfigSidebar: () => void;
475
+ onMenuToggle: () => void;
476
+ closeMobileMenu: () => void;
477
+ setActivePath: (activePath: string | null) => void;
478
+ setExpanded: (key: string, expanded: boolean) => void;
479
+ toggleSidebar: () => void;
480
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
481
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
482
+ setPreset: (preset: string) => void;
483
+ setPrimary: (primary: string) => void;
484
+ setSurface: (surface: string | null) => void;
485
+ isDesktop: () => boolean;
486
+ setDesktop: (desktop: boolean) => void;
487
+ reset: () => void;
488
+ } & import("@ngrx/signals").StateSource<{
489
+ preset: string;
490
+ primary: string;
491
+ surface: string | undefined | null;
492
+ darkTheme: boolean;
493
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
494
+ staticMenuDesktopInactive: boolean;
495
+ overlayMenuActive: boolean;
496
+ configSidebarVisible: boolean;
497
+ mobileMenuActive: boolean;
498
+ menuHoverActive: boolean;
499
+ activePath: string | null;
500
+ sidebarCollapsed: boolean;
501
+ desktop: boolean;
502
+ expandedKeys: string[];
503
+ }>;
504
+ platformId: Object;
505
+ presetOptions: string[];
506
+ showMenuModeButton: import("@angular/core").WritableSignal<boolean>;
507
+ menuModeOptions: {
508
+ label: string;
509
+ value: string;
510
+ }[];
511
+ surfaces: SurfacesType[];
512
+ selectedPrimaryColor: import("@angular/core").Signal<string>;
513
+ selectedSurfaceColor: import("@angular/core").Signal<string | null | undefined>;
514
+ selectedPreset: import("@angular/core").Signal<string>;
515
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
516
+ primaryColors: import("@angular/core").Signal<SurfacesType[]>;
517
+ ngOnInit(): void;
518
+ getPresetExt(): {
519
+ semantic: {
520
+ primary: {
252
521
  0?: string;
253
522
  50?: string;
254
523
  100?: string;
@@ -261,529 +530,439 @@ declare type SurfacesType = {
261
530
  800?: string;
262
531
  900?: string;
263
532
  950?: string;
264
- };
265
- };
266
- declare class HelixConfigurator implements OnInit {
267
- router: Router;
268
- primeng: HelixConfig;
269
- store: {
270
- preset: _angular_core.Signal<string>;
271
- primary: _angular_core.Signal<string>;
272
- surface: _angular_core.Signal<string | null | undefined>;
273
- darkTheme: _angular_core.Signal<boolean>;
274
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
275
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
276
- overlayMenuActive: _angular_core.Signal<boolean>;
277
- configSidebarVisible: _angular_core.Signal<boolean>;
278
- mobileMenuActive: _angular_core.Signal<boolean>;
279
- menuHoverActive: _angular_core.Signal<boolean>;
280
- activePath: _angular_core.Signal<string | null>;
281
- sidebarCollapsed: _angular_core.Signal<boolean>;
282
- expandedRoot: _angular_core.Signal<string | null>;
283
- isDarkTheme: _angular_core.Signal<boolean>;
284
- isOverlay: _angular_core.Signal<boolean>;
285
- isStatic: _angular_core.Signal<boolean>;
286
- isSidebarActive: _angular_core.Signal<boolean>;
287
- isCollapsed: _angular_core.Signal<boolean>;
288
- toggleDarkMode: () => void;
289
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
290
- showConfigSidebar: () => void;
291
- hideConfigSidebar: () => void;
292
- onMenuToggle: () => void;
293
- closeMobileMenu: () => void;
294
- setActivePath: (activePath: string | null) => void;
295
- setExpandedRoot: (key: string | null) => void;
296
- toggleSidebar: () => void;
297
- setMenuHoverActive: (menuHoverActive: boolean) => void;
298
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
299
- setPreset: (preset: string) => void;
300
- setPrimary: (primary: string) => void;
301
- setSurface: (surface: string | null) => void;
302
- isDesktop: () => boolean;
303
- reset: () => void;
304
- } & _ngrx_signals.StateSource<{
305
- preset: string;
306
- primary: string;
307
- surface: string | undefined | null;
308
- darkTheme: boolean;
309
- menuMode: _gravionlabs_helix_shell.MenuMode;
310
- staticMenuDesktopInactive: boolean;
311
- overlayMenuActive: boolean;
312
- configSidebarVisible: boolean;
313
- mobileMenuActive: boolean;
314
- menuHoverActive: boolean;
315
- activePath: string | null;
316
- sidebarCollapsed: boolean;
317
- expandedRoot: string | null;
318
- }>;
319
- platformId: Object;
320
- presetOptions: string[];
321
- showMenuModeButton: _angular_core.WritableSignal<boolean>;
322
- menuModeOptions: {
323
- label: string;
324
- value: string;
325
- }[];
326
- surfaces: SurfacesType[];
327
- selectedPrimaryColor: _angular_core.Signal<string>;
328
- selectedSurfaceColor: _angular_core.Signal<string | null | undefined>;
329
- selectedPreset: _angular_core.Signal<string>;
330
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
331
- primaryColors: _angular_core.Signal<SurfacesType[]>;
332
- ngOnInit(): void;
333
- getPresetExt(): {
334
- semantic: {
335
- primary: {
336
- 0?: string;
337
- 50?: string;
338
- 100?: string;
339
- 200?: string;
340
- 300?: string;
341
- 400?: string;
342
- 500?: string;
343
- 600?: string;
344
- 700?: string;
345
- 800?: string;
346
- 900?: string;
347
- 950?: string;
348
- } | undefined;
349
- colorScheme: {
350
- light: {
351
- primary: {
352
- color: string;
353
- contrastColor: string;
354
- hoverColor: string;
355
- activeColor: string;
356
- };
357
- highlight: {
358
- background: string;
359
- focusBackground: string;
360
- color: string;
361
- focusColor: string;
362
- };
363
- };
364
- dark: {
365
- primary: {
366
- color: string;
367
- contrastColor: string;
368
- hoverColor: string;
369
- activeColor: string;
370
- };
371
- highlight: {
372
- background: string;
373
- focusBackground: string;
374
- color: string;
375
- focusColor: string;
376
- };
377
- };
378
- };
533
+ } | undefined;
534
+ colorScheme: {
535
+ light: {
536
+ primary: {
537
+ color: string;
538
+ contrastColor: string;
539
+ hoverColor: string;
540
+ activeColor: string;
541
+ };
542
+ highlight: {
543
+ background: string;
544
+ focusBackground: string;
545
+ color: string;
546
+ focusColor: string;
547
+ };
379
548
  };
549
+ dark: {
550
+ primary: {
551
+ color: string;
552
+ contrastColor: string;
553
+ hoverColor: string;
554
+ activeColor: string;
555
+ };
556
+ highlight: {
557
+ background: string;
558
+ focusBackground: string;
559
+ color: string;
560
+ focusColor: string;
561
+ };
562
+ };
563
+ };
380
564
  };
381
- updateColors(event: Event, type: string, color: SurfacesType): void;
382
- applyTheme(type: string, color: SurfacesType): void;
383
- onPresetChange(event: string): void;
384
- onMenuModeChange(event: string): void;
385
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixConfigurator, never>;
386
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixConfigurator, "helix-configurator", never, {}, {}, never, never, true, never>;
387
- }
388
-
389
- declare class HelixFloatingConfigurator {
390
- store: {
391
- preset: _angular_core.Signal<string>;
392
- primary: _angular_core.Signal<string>;
393
- surface: _angular_core.Signal<string | null | undefined>;
394
- darkTheme: _angular_core.Signal<boolean>;
395
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
396
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
397
- overlayMenuActive: _angular_core.Signal<boolean>;
398
- configSidebarVisible: _angular_core.Signal<boolean>;
399
- mobileMenuActive: _angular_core.Signal<boolean>;
400
- menuHoverActive: _angular_core.Signal<boolean>;
401
- activePath: _angular_core.Signal<string | null>;
402
- sidebarCollapsed: _angular_core.Signal<boolean>;
403
- expandedRoot: _angular_core.Signal<string | null>;
404
- isDarkTheme: _angular_core.Signal<boolean>;
405
- isOverlay: _angular_core.Signal<boolean>;
406
- isStatic: _angular_core.Signal<boolean>;
407
- isSidebarActive: _angular_core.Signal<boolean>;
408
- isCollapsed: _angular_core.Signal<boolean>;
409
- toggleDarkMode: () => void;
410
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
411
- showConfigSidebar: () => void;
412
- hideConfigSidebar: () => void;
413
- onMenuToggle: () => void;
414
- closeMobileMenu: () => void;
415
- setActivePath: (activePath: string | null) => void;
416
- setExpandedRoot: (key: string | null) => void;
417
- toggleSidebar: () => void;
418
- setMenuHoverActive: (menuHoverActive: boolean) => void;
419
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
420
- setPreset: (preset: string) => void;
421
- setPrimary: (primary: string) => void;
422
- setSurface: (surface: string | null) => void;
423
- isDesktop: () => boolean;
424
- reset: () => void;
425
- } & _ngrx_signals.StateSource<{
426
- preset: string;
427
- primary: string;
428
- surface: string | undefined | null;
429
- darkTheme: boolean;
430
- menuMode: _gravionlabs_helix_shell.MenuMode;
431
- staticMenuDesktopInactive: boolean;
432
- overlayMenuActive: boolean;
433
- configSidebarVisible: boolean;
434
- mobileMenuActive: boolean;
435
- menuHoverActive: boolean;
436
- activePath: string | null;
437
- sidebarCollapsed: boolean;
438
- expandedRoot: string | null;
439
- }>;
440
- float: _angular_core.InputSignal<boolean>;
441
- isDarkTheme: _angular_core.Signal<boolean>;
442
- toggleDarkMode(): void;
443
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFloatingConfigurator, never>;
444
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixFloatingConfigurator, "helix-floating-configurator", never, { "float": { "alias": "float"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
445
- }
446
-
565
+ };
566
+ updateColors(event: Event, type: string, color: SurfacesType): void;
567
+ applyTheme(type: string, color: SurfacesType): void;
568
+ onPresetChange(event: string): void;
569
+ onMenuModeChange(event: string): void;
570
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixConfigurator, never>;
571
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixConfigurator, "helix-configurator", never, {}, {}, never, never, true, never>;
572
+ }
573
+ export declare class HelixFloatingConfigurator {
574
+ store: {
575
+ preset: import("@angular/core").Signal<string>;
576
+ primary: import("@angular/core").Signal<string>;
577
+ surface: import("@angular/core").Signal<string | null | undefined>;
578
+ darkTheme: import("@angular/core").Signal<boolean>;
579
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
580
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
581
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
582
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
583
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
584
+ menuHoverActive: import("@angular/core").Signal<boolean>;
585
+ activePath: import("@angular/core").Signal<string | null>;
586
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
587
+ desktop: import("@angular/core").Signal<boolean>;
588
+ expandedKeys: import("@angular/core").Signal<string[]>;
589
+ isDarkTheme: import("@angular/core").Signal<boolean>;
590
+ isOverlay: import("@angular/core").Signal<boolean>;
591
+ isStatic: import("@angular/core").Signal<boolean>;
592
+ isSidebarActive: import("@angular/core").Signal<boolean>;
593
+ isCollapsed: import("@angular/core").Signal<boolean>;
594
+ toggleDarkMode: () => void;
595
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
596
+ showConfigSidebar: () => void;
597
+ hideConfigSidebar: () => void;
598
+ onMenuToggle: () => void;
599
+ closeMobileMenu: () => void;
600
+ setActivePath: (activePath: string | null) => void;
601
+ setExpanded: (key: string, expanded: boolean) => void;
602
+ toggleSidebar: () => void;
603
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
604
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
605
+ setPreset: (preset: string) => void;
606
+ setPrimary: (primary: string) => void;
607
+ setSurface: (surface: string | null) => void;
608
+ isDesktop: () => boolean;
609
+ setDesktop: (desktop: boolean) => void;
610
+ reset: () => void;
611
+ } & import("@ngrx/signals").StateSource<{
612
+ preset: string;
613
+ primary: string;
614
+ surface: string | undefined | null;
615
+ darkTheme: boolean;
616
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
617
+ staticMenuDesktopInactive: boolean;
618
+ overlayMenuActive: boolean;
619
+ configSidebarVisible: boolean;
620
+ mobileMenuActive: boolean;
621
+ menuHoverActive: boolean;
622
+ activePath: string | null;
623
+ sidebarCollapsed: boolean;
624
+ desktop: boolean;
625
+ expandedKeys: string[];
626
+ }>;
627
+ float: import("@angular/core").InputSignal<boolean>;
628
+ isDarkTheme: import("@angular/core").Signal<boolean>;
629
+ toggleDarkMode(): void;
630
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixFloatingConfigurator, never>;
631
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixFloatingConfigurator, "helix-floating-configurator", never, {
632
+ "float": {
633
+ "alias": "float";
634
+ "required": false;
635
+ "isSignal": true;
636
+ };
637
+ }, {}, never, never, true, never>;
638
+ }
447
639
  interface HelixFooterLink {
448
- label: string;
449
- url?: string;
450
- route?: string;
640
+ label: string;
641
+ url?: string;
642
+ route?: string;
451
643
  }
452
644
  interface HelixFooterColumn {
453
- title: string;
454
- links: HelixFooterLink[];
455
- }
456
-
457
- declare class HelixFooter {
458
- brandName: _angular_core.InputSignal<string>;
459
- brandUrl: _angular_core.InputSignal<string>;
460
- columns: _angular_core.InputSignal<HelixFooterColumn[]>;
461
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFooter, never>;
462
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixFooter, "helix-footer", never, { "brandName": { "alias": "brandName"; "required": false; "isSignal": true; }; "brandUrl": { "alias": "brandUrl"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, {}, never, ["[helixFooterStart]", "*"], true, never>;
463
- }
464
-
465
- /**
466
- * A group of nav-rail items under an optional uppercase section label.
467
- * Reuses HelixRouteMenuItem for items so existing routerLink/path-driven
468
- * active state, breadcrumbs, and route generation keep working unchanged.
469
- */
470
- interface HelixNavGroup {
471
- /** Uppercase section label shown above the items. Omit for an unlabeled group. */
472
- section?: string;
473
- items: HelixRouteMenuItem[];
645
+ title: string;
646
+ links: HelixFooterLink[];
474
647
  }
475
- /**
476
- * Adapts a flat HelixRouteMenuItem tree (as used by HelixAppLayout's `menu`
477
- * input) into HelixNavGroup[] by wrapping it as a single unlabeled group.
478
- * Each top-level item keeps its own identity (icon, children, etc.), so an
479
- * item with children renders as a normal expandable HelixNavRailItem rather
480
- * than being flattened into a static section heading.
481
- */
482
- declare function helixNavGroupsFromMenu(items: HelixRouteMenuItem[]): HelixNavGroup[];
483
-
484
- declare class HelixNavRail implements OnInit, OnDestroy {
485
- store: {
486
- preset: _angular_core.Signal<string>;
487
- primary: _angular_core.Signal<string>;
488
- surface: _angular_core.Signal<string | null | undefined>;
489
- darkTheme: _angular_core.Signal<boolean>;
490
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
491
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
492
- overlayMenuActive: _angular_core.Signal<boolean>;
493
- configSidebarVisible: _angular_core.Signal<boolean>;
494
- mobileMenuActive: _angular_core.Signal<boolean>;
495
- menuHoverActive: _angular_core.Signal<boolean>;
496
- activePath: _angular_core.Signal<string | null>;
497
- sidebarCollapsed: _angular_core.Signal<boolean>;
498
- expandedRoot: _angular_core.Signal<string | null>;
499
- isDarkTheme: _angular_core.Signal<boolean>;
500
- isOverlay: _angular_core.Signal<boolean>;
501
- isStatic: _angular_core.Signal<boolean>;
502
- isSidebarActive: _angular_core.Signal<boolean>;
503
- isCollapsed: _angular_core.Signal<boolean>;
504
- toggleDarkMode: () => void;
505
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
506
- showConfigSidebar: () => void;
507
- hideConfigSidebar: () => void;
508
- onMenuToggle: () => void;
509
- closeMobileMenu: () => void;
510
- setActivePath: (activePath: string | null) => void;
511
- setExpandedRoot: (key: string | null) => void;
512
- toggleSidebar: () => void;
513
- setMenuHoverActive: (menuHoverActive: boolean) => void;
514
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
515
- setPreset: (preset: string) => void;
516
- setPrimary: (primary: string) => void;
517
- setSurface: (surface: string | null) => void;
518
- isDesktop: () => boolean;
519
- reset: () => void;
520
- } & _ngrx_signals.StateSource<{
521
- preset: string;
522
- primary: string;
523
- surface: string | undefined | null;
524
- darkTheme: boolean;
525
- menuMode: _gravionlabs_helix_shell.MenuMode;
526
- staticMenuDesktopInactive: boolean;
527
- overlayMenuActive: boolean;
528
- configSidebarVisible: boolean;
529
- mobileMenuActive: boolean;
530
- menuHoverActive: boolean;
531
- activePath: string | null;
532
- sidebarCollapsed: boolean;
533
- expandedRoot: string | null;
534
- }>;
535
- router: Router;
536
- el: ElementRef<any>;
537
- private sanitizer;
538
- /** Grouped navigation model. Each group renders an optional uppercase section label. */
539
- model: _angular_core.InputSignal<HelixNavGroup[]>;
540
- /** Application title shown in the brand area. Hidden when nav is collapsed. */
541
- appTitle: _angular_core.InputSignal<string>;
542
- /**
543
- * Brand icon: inline SVG (`<svg>…</svg>`) or URL to an SVG file.
544
- * Falls back to the default hardcoded icon when not provided.
545
- */
546
- brandIcon: _angular_core.InputSignal<string | undefined>;
547
- protected isInlineSvg: _angular_core.Signal<boolean>;
548
- protected safeBrandIcon: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
549
- private outsideClickListener;
550
- private destroy$;
551
- constructor();
552
- ngOnInit(): void;
553
- ngOnDestroy(): void;
554
- private onRouteChange;
555
- private bindOutsideClickListener;
556
- private unbindOutsideClickListener;
557
- private isOutsideClicked;
558
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixNavRail, never>;
559
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixNavRail, "helix-nav-rail", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "brandIcon": { "alias": "brandIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
560
- }
561
-
562
- declare class HelixNavRailItem implements AfterViewInit {
563
- store: {
564
- preset: _angular_core.Signal<string>;
565
- primary: _angular_core.Signal<string>;
566
- surface: _angular_core.Signal<string | null | undefined>;
567
- darkTheme: _angular_core.Signal<boolean>;
568
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
569
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
570
- overlayMenuActive: _angular_core.Signal<boolean>;
571
- configSidebarVisible: _angular_core.Signal<boolean>;
572
- mobileMenuActive: _angular_core.Signal<boolean>;
573
- menuHoverActive: _angular_core.Signal<boolean>;
574
- activePath: _angular_core.Signal<string | null>;
575
- sidebarCollapsed: _angular_core.Signal<boolean>;
576
- expandedRoot: _angular_core.Signal<string | null>;
577
- isDarkTheme: _angular_core.Signal<boolean>;
578
- isOverlay: _angular_core.Signal<boolean>;
579
- isStatic: _angular_core.Signal<boolean>;
580
- isSidebarActive: _angular_core.Signal<boolean>;
581
- isCollapsed: _angular_core.Signal<boolean>;
582
- toggleDarkMode: () => void;
583
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
584
- showConfigSidebar: () => void;
585
- hideConfigSidebar: () => void;
586
- onMenuToggle: () => void;
587
- closeMobileMenu: () => void;
588
- setActivePath: (activePath: string | null) => void;
589
- setExpandedRoot: (key: string | null) => void;
590
- toggleSidebar: () => void;
591
- setMenuHoverActive: (menuHoverActive: boolean) => void;
592
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
593
- setPreset: (preset: string) => void;
594
- setPrimary: (primary: string) => void;
595
- setSurface: (surface: string | null) => void;
596
- isDesktop: () => boolean;
597
- reset: () => void;
598
- } & _ngrx_signals.StateSource<{
599
- preset: string;
600
- primary: string;
601
- surface: string | undefined | null;
602
- darkTheme: boolean;
603
- menuMode: _gravionlabs_helix_shell.MenuMode;
604
- staticMenuDesktopInactive: boolean;
605
- overlayMenuActive: boolean;
606
- configSidebarVisible: boolean;
607
- mobileMenuActive: boolean;
608
- menuHoverActive: boolean;
609
- activePath: string | null;
610
- sidebarCollapsed: boolean;
611
- expandedRoot: string | null;
612
- }>;
613
- item: _angular_core.InputSignal<HelixRouteMenuItem | null>;
614
- parentPath: _angular_core.InputSignal<string | null>;
615
- depth: _angular_core.InputSignal<number>;
616
- /** Whether this item's submenu, having animated open at least once, may transition on leave too. */
617
- initialized: _angular_core.WritableSignal<boolean>;
618
- hasChildren: _angular_core.Signal<boolean>;
619
- isCollapsed: _angular_core.Signal<boolean>;
620
- /** Stable key used against LayoutStore.expandedRoot() — only one item app-wide is expanded at a time. */
621
- itemKey: _angular_core.Signal<string>;
622
- fullPath: _angular_core.Signal<string | null>;
623
- isActive: _angular_core.Signal<boolean>;
624
- hasActiveDescendant: _angular_core.Signal<boolean>;
625
- isExpanded: _angular_core.Signal<boolean>;
626
- ngAfterViewInit(): void;
627
- itemClick(event: Event): void;
628
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixNavRailItem, never>;
629
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixNavRailItem, "[helix-nav-rail-item]", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "parentPath": { "alias": "parentPath"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
630
- }
631
-
632
- declare class HelixStatusBar {
633
- brand: _angular_core.InputSignal<string>;
634
- environment: _angular_core.InputSignal<string | undefined>;
635
- note: _angular_core.InputSignal<string | undefined>;
636
- versions: _angular_core.InputSignal<HelixStatusBarVersion[]>;
637
- tone: _angular_core.InputSignal<HelixStatusBarTone>;
638
- height: _angular_core.InputSignal<string>;
639
- protected envForBadge: _angular_core.Signal<Environment | undefined>;
640
- protected bgColor: _angular_core.Signal<string>;
641
- protected textColor: _angular_core.Signal<string>;
642
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixStatusBar, never>;
643
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixStatusBar, "helix-status-bar", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; "environment": { "alias": "environment"; "required": false; "isSignal": true; }; "note": { "alias": "note"; "required": false; "isSignal": true; }; "versions": { "alias": "versions"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
644
- }
645
-
646
- declare class HelixConfiguratorAction {
647
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixConfiguratorAction, never>;
648
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixConfiguratorAction, "helix-configurator-action", never, {}, {}, never, never, true, never>;
649
- }
650
-
651
- declare class HelixDarkModeAction {
652
- protected store: {
653
- preset: _angular_core.Signal<string>;
654
- primary: _angular_core.Signal<string>;
655
- surface: _angular_core.Signal<string | null | undefined>;
656
- darkTheme: _angular_core.Signal<boolean>;
657
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
658
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
659
- overlayMenuActive: _angular_core.Signal<boolean>;
660
- configSidebarVisible: _angular_core.Signal<boolean>;
661
- mobileMenuActive: _angular_core.Signal<boolean>;
662
- menuHoverActive: _angular_core.Signal<boolean>;
663
- activePath: _angular_core.Signal<string | null>;
664
- sidebarCollapsed: _angular_core.Signal<boolean>;
665
- expandedRoot: _angular_core.Signal<string | null>;
666
- isDarkTheme: _angular_core.Signal<boolean>;
667
- isOverlay: _angular_core.Signal<boolean>;
668
- isStatic: _angular_core.Signal<boolean>;
669
- isSidebarActive: _angular_core.Signal<boolean>;
670
- isCollapsed: _angular_core.Signal<boolean>;
671
- toggleDarkMode: () => void;
672
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
673
- showConfigSidebar: () => void;
674
- hideConfigSidebar: () => void;
675
- onMenuToggle: () => void;
676
- closeMobileMenu: () => void;
677
- setActivePath: (activePath: string | null) => void;
678
- setExpandedRoot: (key: string | null) => void;
679
- toggleSidebar: () => void;
680
- setMenuHoverActive: (menuHoverActive: boolean) => void;
681
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
682
- setPreset: (preset: string) => void;
683
- setPrimary: (primary: string) => void;
684
- setSurface: (surface: string | null) => void;
685
- isDesktop: () => boolean;
686
- reset: () => void;
687
- } & _ngrx_signals.StateSource<{
688
- preset: string;
689
- primary: string;
690
- surface: string | undefined | null;
691
- darkTheme: boolean;
692
- menuMode: _gravionlabs_helix_shell.MenuMode;
693
- staticMenuDesktopInactive: boolean;
694
- overlayMenuActive: boolean;
695
- configSidebarVisible: boolean;
696
- mobileMenuActive: boolean;
697
- menuHoverActive: boolean;
698
- activePath: string | null;
699
- sidebarCollapsed: boolean;
700
- expandedRoot: string | null;
701
- }>;
702
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixDarkModeAction, never>;
703
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixDarkModeAction, "helix-dark-mode-action", never, {}, {}, never, never, true, never>;
704
- }
705
-
706
- declare class HelixMobileMenuAction {
707
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixMobileMenuAction, never>;
708
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixMobileMenuAction, "helix-mobile-menu-action", never, {}, {}, never, never, true, never>;
709
- }
710
-
711
- declare class HelixTopbar implements OnInit, OnDestroy {
712
- appTitle: _angular_core.InputSignal<string>;
713
- topbarActions: _angular_core.InputSignal<HelixTopbarAction[]>;
714
- breadcrumbs: _angular_core.InputSignal<MenuItem[] | undefined>;
715
- items: _angular_core.InputSignal<HelixTopbarItem[]>;
716
- store: {
717
- preset: _angular_core.Signal<string>;
718
- primary: _angular_core.Signal<string>;
719
- surface: _angular_core.Signal<string | null | undefined>;
720
- darkTheme: _angular_core.Signal<boolean>;
721
- menuMode: _angular_core.Signal<_gravionlabs_helix_shell.MenuMode>;
722
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
723
- overlayMenuActive: _angular_core.Signal<boolean>;
724
- configSidebarVisible: _angular_core.Signal<boolean>;
725
- mobileMenuActive: _angular_core.Signal<boolean>;
726
- menuHoverActive: _angular_core.Signal<boolean>;
727
- activePath: _angular_core.Signal<string | null>;
728
- sidebarCollapsed: _angular_core.Signal<boolean>;
729
- expandedRoot: _angular_core.Signal<string | null>;
730
- isDarkTheme: _angular_core.Signal<boolean>;
731
- isOverlay: _angular_core.Signal<boolean>;
732
- isStatic: _angular_core.Signal<boolean>;
733
- isSidebarActive: _angular_core.Signal<boolean>;
734
- isCollapsed: _angular_core.Signal<boolean>;
735
- toggleDarkMode: () => void;
736
- setMenuMode: (menuMode: _gravionlabs_helix_shell.MenuMode) => void;
737
- showConfigSidebar: () => void;
738
- hideConfigSidebar: () => void;
739
- onMenuToggle: () => void;
740
- closeMobileMenu: () => void;
741
- setActivePath: (activePath: string | null) => void;
742
- setExpandedRoot: (key: string | null) => void;
743
- toggleSidebar: () => void;
744
- setMenuHoverActive: (menuHoverActive: boolean) => void;
745
- updateConfig: (config: Partial<_gravionlabs_helix_shell.LayoutConfig>) => void;
746
- setPreset: (preset: string) => void;
747
- setPrimary: (primary: string) => void;
748
- setSurface: (surface: string | null) => void;
749
- isDesktop: () => boolean;
750
- reset: () => void;
751
- } & _ngrx_signals.StateSource<{
752
- preset: string;
753
- primary: string;
754
- surface: string | undefined | null;
755
- darkTheme: boolean;
756
- menuMode: _gravionlabs_helix_shell.MenuMode;
757
- staticMenuDesktopInactive: boolean;
758
- overlayMenuActive: boolean;
759
- configSidebarVisible: boolean;
760
- mobileMenuActive: boolean;
761
- menuHoverActive: boolean;
762
- activePath: string | null;
763
- sidebarCollapsed: boolean;
764
- expandedRoot: string | null;
765
- }>;
766
- private router;
767
- private route;
768
- private destroy$;
769
- private routeChange;
770
- ngOnInit(): void;
771
- ngOnDestroy(): void;
772
- protected effectiveBreadcrumbs: _angular_core.Signal<MenuItem[]>;
773
- protected showBreadcrumbs: _angular_core.Signal<boolean>;
774
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixTopbar, never>;
775
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixTopbar, "helix-topbar", never, { "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "topbarActions": { "alias": "topbarActions"; "required": false; "isSignal": true; }; "breadcrumbs": { "alias": "breadcrumbs"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, ["[helixTopbarEnd]"], true, never>;
776
- }
777
-
778
- type MenuMode = 'static' | 'overlay';
779
- interface LayoutConfig {
648
+ export declare class HelixFooter {
649
+ brandName: import("@angular/core").InputSignal<string>;
650
+ brandUrl: import("@angular/core").InputSignal<string>;
651
+ columns: import("@angular/core").InputSignal<HelixFooterColumn[]>;
652
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixFooter, never>;
653
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixFooter, "helix-footer", never, {
654
+ "brandName": {
655
+ "alias": "brandName";
656
+ "required": false;
657
+ "isSignal": true;
658
+ };
659
+ "brandUrl": {
660
+ "alias": "brandUrl";
661
+ "required": false;
662
+ "isSignal": true;
663
+ };
664
+ "columns": {
665
+ "alias": "columns";
666
+ "required": false;
667
+ "isSignal": true;
668
+ };
669
+ }, {}, never, ["[helixFooterStart]", "*"], true, never>;
670
+ }
671
+ export declare class HelixNavRail implements OnInit, OnDestroy {
672
+ store: {
673
+ preset: import("@angular/core").Signal<string>;
674
+ primary: import("@angular/core").Signal<string>;
675
+ surface: import("@angular/core").Signal<string | null | undefined>;
676
+ darkTheme: import("@angular/core").Signal<boolean>;
677
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
678
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
679
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
680
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
681
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
682
+ menuHoverActive: import("@angular/core").Signal<boolean>;
683
+ activePath: import("@angular/core").Signal<string | null>;
684
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
685
+ desktop: import("@angular/core").Signal<boolean>;
686
+ expandedKeys: import("@angular/core").Signal<string[]>;
687
+ isDarkTheme: import("@angular/core").Signal<boolean>;
688
+ isOverlay: import("@angular/core").Signal<boolean>;
689
+ isStatic: import("@angular/core").Signal<boolean>;
690
+ isSidebarActive: import("@angular/core").Signal<boolean>;
691
+ isCollapsed: import("@angular/core").Signal<boolean>;
692
+ toggleDarkMode: () => void;
693
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
694
+ showConfigSidebar: () => void;
695
+ hideConfigSidebar: () => void;
696
+ onMenuToggle: () => void;
697
+ closeMobileMenu: () => void;
698
+ setActivePath: (activePath: string | null) => void;
699
+ setExpanded: (key: string, expanded: boolean) => void;
700
+ toggleSidebar: () => void;
701
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
702
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
703
+ setPreset: (preset: string) => void;
704
+ setPrimary: (primary: string) => void;
705
+ setSurface: (surface: string | null) => void;
706
+ isDesktop: () => boolean;
707
+ setDesktop: (desktop: boolean) => void;
708
+ reset: () => void;
709
+ } & import("@ngrx/signals").StateSource<{
780
710
  preset: string;
781
711
  primary: string;
782
712
  surface: string | undefined | null;
783
713
  darkTheme: boolean;
784
- menuMode: MenuMode;
714
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
715
+ staticMenuDesktopInactive: boolean;
716
+ overlayMenuActive: boolean;
717
+ configSidebarVisible: boolean;
718
+ mobileMenuActive: boolean;
719
+ menuHoverActive: boolean;
720
+ activePath: string | null;
721
+ sidebarCollapsed: boolean;
722
+ desktop: boolean;
723
+ expandedKeys: string[];
724
+ }>;
725
+ router: Router;
726
+ el: ElementRef<any>;
727
+ private sanitizer;
728
+ /** Grouped navigation model. Each group renders an optional uppercase section label. */
729
+ model: import("@angular/core").InputSignal<HelixNavGroup[]>;
730
+ /** Application title shown in the brand area. Hidden when nav is collapsed. */
731
+ appTitle: import("@angular/core").InputSignal<string>;
732
+ /**
733
+ * Brand icon: inline SVG (`<svg>…</svg>`) or URL to an SVG file.
734
+ * Falls back to the default hardcoded icon when not provided.
735
+ */
736
+ brandIcon: import("@angular/core").InputSignal<string | undefined>;
737
+ protected isInlineSvg: import("@angular/core").Signal<boolean>;
738
+ protected safeBrandIcon: import("@angular/core").Signal<import("@angular/platform-browser").SafeHtml | null>;
739
+ private outsideClickListener;
740
+ private destroy$;
741
+ constructor();
742
+ ngOnInit(): void;
743
+ ngOnDestroy(): void;
744
+ private onRouteChange;
745
+ private bindOutsideClickListener;
746
+ private unbindOutsideClickListener;
747
+ private isOutsideClicked;
748
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixNavRail, never>;
749
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixNavRail, "helix-nav-rail", never, {
750
+ "model": {
751
+ "alias": "model";
752
+ "required": false;
753
+ "isSignal": true;
754
+ };
755
+ "appTitle": {
756
+ "alias": "appTitle";
757
+ "required": false;
758
+ "isSignal": true;
759
+ };
760
+ "brandIcon": {
761
+ "alias": "brandIcon";
762
+ "required": false;
763
+ "isSignal": true;
764
+ };
765
+ }, {}, never, never, true, never>;
785
766
  }
786
- interface LayoutState {
767
+ export declare class HelixNavRailItem implements AfterViewInit {
768
+ #private;
769
+ store: {
770
+ preset: import("@angular/core").Signal<string>;
771
+ primary: import("@angular/core").Signal<string>;
772
+ surface: import("@angular/core").Signal<string | null | undefined>;
773
+ darkTheme: import("@angular/core").Signal<boolean>;
774
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
775
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
776
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
777
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
778
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
779
+ menuHoverActive: import("@angular/core").Signal<boolean>;
780
+ activePath: import("@angular/core").Signal<string | null>;
781
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
782
+ desktop: import("@angular/core").Signal<boolean>;
783
+ expandedKeys: import("@angular/core").Signal<string[]>;
784
+ isDarkTheme: import("@angular/core").Signal<boolean>;
785
+ isOverlay: import("@angular/core").Signal<boolean>;
786
+ isStatic: import("@angular/core").Signal<boolean>;
787
+ isSidebarActive: import("@angular/core").Signal<boolean>;
788
+ isCollapsed: import("@angular/core").Signal<boolean>;
789
+ toggleDarkMode: () => void;
790
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
791
+ showConfigSidebar: () => void;
792
+ hideConfigSidebar: () => void;
793
+ onMenuToggle: () => void;
794
+ closeMobileMenu: () => void;
795
+ setActivePath: (activePath: string | null) => void;
796
+ setExpanded: (key: string, expanded: boolean) => void;
797
+ toggleSidebar: () => void;
798
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
799
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
800
+ setPreset: (preset: string) => void;
801
+ setPrimary: (primary: string) => void;
802
+ setSurface: (surface: string | null) => void;
803
+ isDesktop: () => boolean;
804
+ setDesktop: (desktop: boolean) => void;
805
+ reset: () => void;
806
+ } & import("@ngrx/signals").StateSource<{
807
+ preset: string;
808
+ primary: string;
809
+ surface: string | undefined | null;
810
+ darkTheme: boolean;
811
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
812
+ staticMenuDesktopInactive: boolean;
813
+ overlayMenuActive: boolean;
814
+ configSidebarVisible: boolean;
815
+ mobileMenuActive: boolean;
816
+ menuHoverActive: boolean;
817
+ activePath: string | null;
818
+ sidebarCollapsed: boolean;
819
+ desktop: boolean;
820
+ expandedKeys: string[];
821
+ }>;
822
+ item: import("@angular/core").InputSignal<HelixRouteMenuItem | null>;
823
+ parentPath: import("@angular/core").InputSignal<string | null>;
824
+ depth: import("@angular/core").InputSignal<number>;
825
+ /** Renders inside a collapsed-rail flyout: always expanded (labels visible), never itself a flyout. */
826
+ flyout: import("@angular/core").InputSignal<boolean>;
827
+ /** Whether this item's submenu, having animated open at least once, may transition on leave too. */
828
+ initialized: import("@angular/core").WritableSignal<boolean>;
829
+ hasChildren: import("@angular/core").Signal<boolean>;
830
+ isCollapsed: import("@angular/core").Signal<boolean>;
831
+ /** Collapsed rail: the item's children are shown in a flyout next to it. */
832
+ flyoutOpen: import("@angular/core").WritableSignal<boolean>;
833
+ flyoutTop: import("@angular/core").WritableSignal<number>;
834
+ flyoutLeft: import("@angular/core").WritableSignal<number>;
835
+ /** Stable key used against LayoutStore.expandedKeys() — several items can be expanded at once. */
836
+ itemKey: import("@angular/core").Signal<string>;
837
+ fullPath: import("@angular/core").Signal<string | null>;
838
+ isActive: import("@angular/core").Signal<boolean>;
839
+ hasActiveDescendant: import("@angular/core").Signal<boolean>;
840
+ isExpanded: import("@angular/core").Signal<boolean>;
841
+ constructor();
842
+ ngAfterViewInit(): void;
843
+ itemClick(event: Event): void;
844
+ openFlyout(): void;
845
+ closeFlyout(restoreFocus: boolean): void;
846
+ scheduleFlyoutClose(): void;
847
+ onFocusOut(event: FocusEvent): void;
848
+ /** Enter/Space activate expandable items; arrow keys move between visible links. */
849
+ onKeydown(event: KeyboardEvent): void;
850
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixNavRailItem, never>;
851
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixNavRailItem, "[helix-nav-rail-item]", never, {
852
+ "item": {
853
+ "alias": "item";
854
+ "required": false;
855
+ "isSignal": true;
856
+ };
857
+ "parentPath": {
858
+ "alias": "parentPath";
859
+ "required": false;
860
+ "isSignal": true;
861
+ };
862
+ "depth": {
863
+ "alias": "depth";
864
+ "required": false;
865
+ "isSignal": true;
866
+ };
867
+ "flyout": {
868
+ "alias": "flyout";
869
+ "required": false;
870
+ "isSignal": true;
871
+ };
872
+ }, {}, never, never, true, never>;
873
+ }
874
+ export declare class HelixStatusBar {
875
+ brand: import("@angular/core").InputSignal<string>;
876
+ environment: import("@angular/core").InputSignal<string | undefined>;
877
+ note: import("@angular/core").InputSignal<string | undefined>;
878
+ versions: import("@angular/core").InputSignal<HelixStatusBarVersion[]>;
879
+ tone: import("@angular/core").InputSignal<HelixStatusBarTone>;
880
+ height: import("@angular/core").InputSignal<string>;
881
+ protected envForBadge: import("@angular/core").Signal<Environment | undefined>;
882
+ protected bgColor: import("@angular/core").Signal<string>;
883
+ protected textColor: import("@angular/core").Signal<string>;
884
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixStatusBar, never>;
885
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixStatusBar, "helix-status-bar", never, {
886
+ "brand": {
887
+ "alias": "brand";
888
+ "required": false;
889
+ "isSignal": true;
890
+ };
891
+ "environment": {
892
+ "alias": "environment";
893
+ "required": false;
894
+ "isSignal": true;
895
+ };
896
+ "note": {
897
+ "alias": "note";
898
+ "required": false;
899
+ "isSignal": true;
900
+ };
901
+ "versions": {
902
+ "alias": "versions";
903
+ "required": false;
904
+ "isSignal": true;
905
+ };
906
+ "tone": {
907
+ "alias": "tone";
908
+ "required": false;
909
+ "isSignal": true;
910
+ };
911
+ "height": {
912
+ "alias": "height";
913
+ "required": false;
914
+ "isSignal": true;
915
+ };
916
+ }, {}, never, never, true, never>;
917
+ }
918
+ export declare class HelixConfiguratorAction {
919
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixConfiguratorAction, never>;
920
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixConfiguratorAction, "helix-configurator-action", never, {}, {}, never, never, true, never>;
921
+ }
922
+ export declare class HelixDarkModeAction {
923
+ protected store: {
924
+ preset: import("@angular/core").Signal<string>;
925
+ primary: import("@angular/core").Signal<string>;
926
+ surface: import("@angular/core").Signal<string | null | undefined>;
927
+ darkTheme: import("@angular/core").Signal<boolean>;
928
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
929
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
930
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
931
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
932
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
933
+ menuHoverActive: import("@angular/core").Signal<boolean>;
934
+ activePath: import("@angular/core").Signal<string | null>;
935
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
936
+ desktop: import("@angular/core").Signal<boolean>;
937
+ expandedKeys: import("@angular/core").Signal<string[]>;
938
+ isDarkTheme: import("@angular/core").Signal<boolean>;
939
+ isOverlay: import("@angular/core").Signal<boolean>;
940
+ isStatic: import("@angular/core").Signal<boolean>;
941
+ isSidebarActive: import("@angular/core").Signal<boolean>;
942
+ isCollapsed: import("@angular/core").Signal<boolean>;
943
+ toggleDarkMode: () => void;
944
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
945
+ showConfigSidebar: () => void;
946
+ hideConfigSidebar: () => void;
947
+ onMenuToggle: () => void;
948
+ closeMobileMenu: () => void;
949
+ setActivePath: (activePath: string | null) => void;
950
+ setExpanded: (key: string, expanded: boolean) => void;
951
+ toggleSidebar: () => void;
952
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
953
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
954
+ setPreset: (preset: string) => void;
955
+ setPrimary: (primary: string) => void;
956
+ setSurface: (surface: string | null) => void;
957
+ isDesktop: () => boolean;
958
+ setDesktop: (desktop: boolean) => void;
959
+ reset: () => void;
960
+ } & import("@ngrx/signals").StateSource<{
961
+ preset: string;
962
+ primary: string;
963
+ surface: string | undefined | null;
964
+ darkTheme: boolean;
965
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
787
966
  staticMenuDesktopInactive: boolean;
788
967
  overlayMenuActive: boolean;
789
968
  configSidebarVisible: boolean;
@@ -791,50 +970,64 @@ interface LayoutState {
791
970
  menuHoverActive: boolean;
792
971
  activePath: string | null;
793
972
  sidebarCollapsed: boolean;
794
- expandedRoot: string | null;
795
- }
796
-
797
- declare const LayoutStore: _angular_core.Type<{
798
- preset: _angular_core.Signal<string>;
799
- primary: _angular_core.Signal<string>;
800
- surface: _angular_core.Signal<string | null | undefined>;
801
- darkTheme: _angular_core.Signal<boolean>;
802
- menuMode: _angular_core.Signal<MenuMode>;
803
- staticMenuDesktopInactive: _angular_core.Signal<boolean>;
804
- overlayMenuActive: _angular_core.Signal<boolean>;
805
- configSidebarVisible: _angular_core.Signal<boolean>;
806
- mobileMenuActive: _angular_core.Signal<boolean>;
807
- menuHoverActive: _angular_core.Signal<boolean>;
808
- activePath: _angular_core.Signal<string | null>;
809
- sidebarCollapsed: _angular_core.Signal<boolean>;
810
- expandedRoot: _angular_core.Signal<string | null>;
811
- isDarkTheme: _angular_core.Signal<boolean>;
812
- isOverlay: _angular_core.Signal<boolean>;
813
- isStatic: _angular_core.Signal<boolean>;
814
- isSidebarActive: _angular_core.Signal<boolean>;
815
- isCollapsed: _angular_core.Signal<boolean>;
973
+ desktop: boolean;
974
+ expandedKeys: string[];
975
+ }>;
976
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixDarkModeAction, never>;
977
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixDarkModeAction, "helix-dark-mode-action", never, {}, {}, never, never, true, never>;
978
+ }
979
+ export declare class HelixMobileMenuAction {
980
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixMobileMenuAction, never>;
981
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixMobileMenuAction, "helix-mobile-menu-action", never, {}, {}, never, never, true, never>;
982
+ }
983
+ export declare class HelixTopbar implements OnInit, OnDestroy {
984
+ appTitle: import("@angular/core").InputSignal<string>;
985
+ topbarActions: import("@angular/core").InputSignal<HelixTopbarAction[]>;
986
+ breadcrumbs: import("@angular/core").InputSignal<MenuItem[] | undefined>;
987
+ items: import("@angular/core").InputSignal<HelixTopbarItem[]>;
988
+ store: {
989
+ preset: import("@angular/core").Signal<string>;
990
+ primary: import("@angular/core").Signal<string>;
991
+ surface: import("@angular/core").Signal<string | null | undefined>;
992
+ darkTheme: import("@angular/core").Signal<boolean>;
993
+ menuMode: import("@angular/core").Signal<import("@gravionlabs/helix-shell").MenuMode>;
994
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
995
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
996
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
997
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
998
+ menuHoverActive: import("@angular/core").Signal<boolean>;
999
+ activePath: import("@angular/core").Signal<string | null>;
1000
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
1001
+ desktop: import("@angular/core").Signal<boolean>;
1002
+ expandedKeys: import("@angular/core").Signal<string[]>;
1003
+ isDarkTheme: import("@angular/core").Signal<boolean>;
1004
+ isOverlay: import("@angular/core").Signal<boolean>;
1005
+ isStatic: import("@angular/core").Signal<boolean>;
1006
+ isSidebarActive: import("@angular/core").Signal<boolean>;
1007
+ isCollapsed: import("@angular/core").Signal<boolean>;
816
1008
  toggleDarkMode: () => void;
817
- setMenuMode: (menuMode: MenuMode) => void;
1009
+ setMenuMode: (menuMode: import("@gravionlabs/helix-shell").MenuMode) => void;
818
1010
  showConfigSidebar: () => void;
819
1011
  hideConfigSidebar: () => void;
820
1012
  onMenuToggle: () => void;
821
1013
  closeMobileMenu: () => void;
822
1014
  setActivePath: (activePath: string | null) => void;
823
- setExpandedRoot: (key: string | null) => void;
1015
+ setExpanded: (key: string, expanded: boolean) => void;
824
1016
  toggleSidebar: () => void;
825
1017
  setMenuHoverActive: (menuHoverActive: boolean) => void;
826
- updateConfig: (config: Partial<LayoutConfig>) => void;
1018
+ updateConfig: (config: Partial<import("@gravionlabs/helix-shell").LayoutConfig>) => void;
827
1019
  setPreset: (preset: string) => void;
828
1020
  setPrimary: (primary: string) => void;
829
1021
  setSurface: (surface: string | null) => void;
830
1022
  isDesktop: () => boolean;
1023
+ setDesktop: (desktop: boolean) => void;
831
1024
  reset: () => void;
832
- } & _ngrx_signals.StateSource<{
1025
+ } & import("@ngrx/signals").StateSource<{
833
1026
  preset: string;
834
1027
  primary: string;
835
1028
  surface: string | undefined | null;
836
1029
  darkTheme: boolean;
837
- menuMode: MenuMode;
1030
+ menuMode: import("@gravionlabs/helix-shell").MenuMode;
838
1031
  staticMenuDesktopInactive: boolean;
839
1032
  overlayMenuActive: boolean;
840
1033
  configSidebarVisible: boolean;
@@ -842,176 +1035,505 @@ declare const LayoutStore: _angular_core.Type<{
842
1035
  menuHoverActive: boolean;
843
1036
  activePath: string | null;
844
1037
  sidebarCollapsed: boolean;
845
- expandedRoot: string | null;
1038
+ desktop: boolean;
1039
+ expandedKeys: string[];
1040
+ }>;
1041
+ private router;
1042
+ private route;
1043
+ private destroy$;
1044
+ private routeChange;
1045
+ ngOnInit(): void;
1046
+ ngOnDestroy(): void;
1047
+ protected effectiveBreadcrumbs: import("@angular/core").Signal<MenuItem[]>;
1048
+ protected showBreadcrumbs: import("@angular/core").Signal<boolean>;
1049
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixTopbar, never>;
1050
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixTopbar, "helix-topbar", never, {
1051
+ "appTitle": {
1052
+ "alias": "appTitle";
1053
+ "required": false;
1054
+ "isSignal": true;
1055
+ };
1056
+ "topbarActions": {
1057
+ "alias": "topbarActions";
1058
+ "required": false;
1059
+ "isSignal": true;
1060
+ };
1061
+ "breadcrumbs": {
1062
+ "alias": "breadcrumbs";
1063
+ "required": false;
1064
+ "isSignal": true;
1065
+ };
1066
+ "items": {
1067
+ "alias": "items";
1068
+ "required": false;
1069
+ "isSignal": true;
1070
+ };
1071
+ }, {}, never, ["[helixTopbarEnd]"], true, never>;
1072
+ }
1073
+ export type MenuMode = 'static' | 'overlay';
1074
+ export interface LayoutConfig {
1075
+ preset: string;
1076
+ primary: string;
1077
+ surface: string | undefined | null;
1078
+ darkTheme: boolean;
1079
+ menuMode: MenuMode;
1080
+ }
1081
+ export interface LayoutState {
1082
+ staticMenuDesktopInactive: boolean;
1083
+ overlayMenuActive: boolean;
1084
+ configSidebarVisible: boolean;
1085
+ mobileMenuActive: boolean;
1086
+ menuHoverActive: boolean;
1087
+ activePath: string | null;
1088
+ sidebarCollapsed: boolean;
1089
+ /** Viewport is above the mobile breakpoint (> 991px). Kept in sync on window resize. */
1090
+ desktop: boolean;
1091
+ /** Keys of the expanded nav-rail items (several can be open at once). */
1092
+ expandedKeys: string[];
1093
+ }
1094
+ export declare const LayoutStore: import("@angular/core").Type<{
1095
+ preset: import("@angular/core").Signal<string>;
1096
+ primary: import("@angular/core").Signal<string>;
1097
+ surface: import("@angular/core").Signal<string | null | undefined>;
1098
+ darkTheme: import("@angular/core").Signal<boolean>;
1099
+ menuMode: import("@angular/core").Signal<MenuMode>;
1100
+ staticMenuDesktopInactive: import("@angular/core").Signal<boolean>;
1101
+ overlayMenuActive: import("@angular/core").Signal<boolean>;
1102
+ configSidebarVisible: import("@angular/core").Signal<boolean>;
1103
+ mobileMenuActive: import("@angular/core").Signal<boolean>;
1104
+ menuHoverActive: import("@angular/core").Signal<boolean>;
1105
+ activePath: import("@angular/core").Signal<string | null>;
1106
+ sidebarCollapsed: import("@angular/core").Signal<boolean>;
1107
+ desktop: import("@angular/core").Signal<boolean>;
1108
+ expandedKeys: import("@angular/core").Signal<string[]>;
1109
+ isDarkTheme: import("@angular/core").Signal<boolean>;
1110
+ isOverlay: import("@angular/core").Signal<boolean>;
1111
+ isStatic: import("@angular/core").Signal<boolean>;
1112
+ isSidebarActive: import("@angular/core").Signal<boolean>;
1113
+ isCollapsed: import("@angular/core").Signal<boolean>;
1114
+ toggleDarkMode: () => void;
1115
+ setMenuMode: (menuMode: MenuMode) => void;
1116
+ showConfigSidebar: () => void;
1117
+ hideConfigSidebar: () => void;
1118
+ onMenuToggle: () => void;
1119
+ closeMobileMenu: () => void;
1120
+ setActivePath: (activePath: string | null) => void;
1121
+ setExpanded: (key: string, expanded: boolean) => void;
1122
+ toggleSidebar: () => void;
1123
+ setMenuHoverActive: (menuHoverActive: boolean) => void;
1124
+ updateConfig: (config: Partial<LayoutConfig>) => void;
1125
+ setPreset: (preset: string) => void;
1126
+ setPrimary: (primary: string) => void;
1127
+ setSurface: (surface: string | null) => void;
1128
+ isDesktop: () => boolean;
1129
+ setDesktop: (desktop: boolean) => void;
1130
+ reset: () => void;
1131
+ } & import("@ngrx/signals").StateSource<{
1132
+ preset: string;
1133
+ primary: string;
1134
+ surface: string | undefined | null;
1135
+ darkTheme: boolean;
1136
+ menuMode: MenuMode;
1137
+ staticMenuDesktopInactive: boolean;
1138
+ overlayMenuActive: boolean;
1139
+ configSidebarVisible: boolean;
1140
+ mobileMenuActive: boolean;
1141
+ menuHoverActive: boolean;
1142
+ activePath: string | null;
1143
+ sidebarCollapsed: boolean;
1144
+ desktop: boolean;
1145
+ expandedKeys: string[];
846
1146
  }>>;
847
-
848
- declare class HelixAccess {
849
- title: _angular_core.InputSignal<string>;
850
- message: _angular_core.InputSignal<string>;
851
- buttonLabel: _angular_core.InputSignal<string>;
852
- buttonRoute: _angular_core.InputSignal<string>;
853
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixAccess, never>;
854
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixAccess, "helix-access", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "buttonRoute": { "alias": "buttonRoute"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
855
- }
856
-
857
- declare const authRoutes: Routes;
858
-
859
- declare class HelixError {
860
- title: _angular_core.InputSignal<string>;
861
- message: _angular_core.InputSignal<string>;
862
- buttonLabel: _angular_core.InputSignal<string>;
863
- buttonRoute: _angular_core.InputSignal<string>;
864
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixError, never>;
865
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixError, "helix-error", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "buttonRoute": { "alias": "buttonRoute"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
866
- }
867
-
1147
+ export declare class HelixAccess {
1148
+ title: import("@angular/core").InputSignal<string>;
1149
+ message: import("@angular/core").InputSignal<string>;
1150
+ buttonLabel: import("@angular/core").InputSignal<string>;
1151
+ buttonRoute: import("@angular/core").InputSignal<string>;
1152
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixAccess, never>;
1153
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixAccess, "helix-access", never, {
1154
+ "title": {
1155
+ "alias": "title";
1156
+ "required": false;
1157
+ "isSignal": true;
1158
+ };
1159
+ "message": {
1160
+ "alias": "message";
1161
+ "required": false;
1162
+ "isSignal": true;
1163
+ };
1164
+ "buttonLabel": {
1165
+ "alias": "buttonLabel";
1166
+ "required": false;
1167
+ "isSignal": true;
1168
+ };
1169
+ "buttonRoute": {
1170
+ "alias": "buttonRoute";
1171
+ "required": false;
1172
+ "isSignal": true;
1173
+ };
1174
+ }, {}, never, never, true, never>;
1175
+ }
1176
+ export declare const authRoutes: Routes;
1177
+ export declare class HelixError {
1178
+ title: import("@angular/core").InputSignal<string>;
1179
+ message: import("@angular/core").InputSignal<string>;
1180
+ buttonLabel: import("@angular/core").InputSignal<string>;
1181
+ buttonRoute: import("@angular/core").InputSignal<string>;
1182
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixError, never>;
1183
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixError, "helix-error", never, {
1184
+ "title": {
1185
+ "alias": "title";
1186
+ "required": false;
1187
+ "isSignal": true;
1188
+ };
1189
+ "message": {
1190
+ "alias": "message";
1191
+ "required": false;
1192
+ "isSignal": true;
1193
+ };
1194
+ "buttonLabel": {
1195
+ "alias": "buttonLabel";
1196
+ "required": false;
1197
+ "isSignal": true;
1198
+ };
1199
+ "buttonRoute": {
1200
+ "alias": "buttonRoute";
1201
+ "required": false;
1202
+ "isSignal": true;
1203
+ };
1204
+ }, {}, never, never, true, never>;
1205
+ }
868
1206
  interface HelixLoginCredentials {
869
- email: string;
870
- password: string;
871
- rememberMe: boolean;
872
- }
873
- declare class HelixLogin {
874
- title: _angular_core.InputSignal<string>;
875
- subtitle: _angular_core.InputSignal<string>;
876
- submitLabel: _angular_core.InputSignal<string>;
877
- forgotPasswordLabel: _angular_core.InputSignal<string>;
878
- login: _angular_core.OutputEmitterRef<HelixLoginCredentials>;
879
- forgotPassword: _angular_core.OutputEmitterRef<void>;
880
- email: string;
881
- password: string;
882
- checked: boolean;
883
- onSubmit(): void;
884
- onForgotPassword(): void;
885
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixLogin, never>;
886
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixLogin, "helix-login", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; "forgotPasswordLabel": { "alias": "forgotPasswordLabel"; "required": false; "isSignal": true; }; }, { "login": "login"; "forgotPassword": "forgotPassword"; }, never, never, true, never>;
887
- }
888
-
889
- declare class HelixEmpty {
890
- title: _angular_core.InputSignal<string>;
891
- description: _angular_core.InputSignal<string>;
892
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixEmpty, never>;
893
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixEmpty, "helix-empty", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
894
- }
895
-
1207
+ email: string;
1208
+ password: string;
1209
+ rememberMe: boolean;
1210
+ }
1211
+ export declare class HelixLogin {
1212
+ title: import("@angular/core").InputSignal<string>;
1213
+ subtitle: import("@angular/core").InputSignal<string>;
1214
+ submitLabel: import("@angular/core").InputSignal<string>;
1215
+ forgotPasswordLabel: import("@angular/core").InputSignal<string>;
1216
+ login: import("@angular/core").OutputEmitterRef<HelixLoginCredentials>;
1217
+ forgotPassword: import("@angular/core").OutputEmitterRef<void>;
1218
+ email: string;
1219
+ password: string;
1220
+ checked: boolean;
1221
+ onSubmit(): void;
1222
+ onForgotPassword(): void;
1223
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixLogin, never>;
1224
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixLogin, "helix-login", never, {
1225
+ "title": {
1226
+ "alias": "title";
1227
+ "required": false;
1228
+ "isSignal": true;
1229
+ };
1230
+ "subtitle": {
1231
+ "alias": "subtitle";
1232
+ "required": false;
1233
+ "isSignal": true;
1234
+ };
1235
+ "submitLabel": {
1236
+ "alias": "submitLabel";
1237
+ "required": false;
1238
+ "isSignal": true;
1239
+ };
1240
+ "forgotPasswordLabel": {
1241
+ "alias": "forgotPasswordLabel";
1242
+ "required": false;
1243
+ "isSignal": true;
1244
+ };
1245
+ }, {
1246
+ "login": "login";
1247
+ "forgotPassword": "forgotPassword";
1248
+ }, never, never, true, never>;
1249
+ }
1250
+ export declare class HelixEmpty {
1251
+ title: import("@angular/core").InputSignal<string>;
1252
+ description: import("@angular/core").InputSignal<string>;
1253
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixEmpty, never>;
1254
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixEmpty, "helix-empty", never, {
1255
+ "title": {
1256
+ "alias": "title";
1257
+ "required": false;
1258
+ "isSignal": true;
1259
+ };
1260
+ "description": {
1261
+ "alias": "description";
1262
+ "required": false;
1263
+ "isSignal": true;
1264
+ };
1265
+ }, {}, never, ["*"], true, never>;
1266
+ }
896
1267
  interface HelixNavLink {
897
- label: string;
898
- route: string;
899
- fragment: string;
1268
+ label: string;
1269
+ route: string;
1270
+ fragment: string;
900
1271
  }
901
1272
  interface HelixFeature {
902
- icon: string;
903
- iconBgClass: string;
904
- iconColorClass: string;
905
- title: string;
906
- description: string;
907
- cardStyle?: string;
1273
+ icon: string;
1274
+ iconBgClass: string;
1275
+ iconColorClass: string;
1276
+ title: string;
1277
+ description: string;
1278
+ cardStyle?: string;
908
1279
  }
909
1280
  interface HelixTestimonial {
910
- name: string;
911
- company: string;
912
- text: string;
913
- logoUrl?: string;
1281
+ name: string;
1282
+ company: string;
1283
+ text: string;
1284
+ logoUrl?: string;
914
1285
  }
915
1286
  interface HelixHighlight {
916
- icon: string;
917
- iconBgClass: string;
918
- iconColorClass: string;
919
- title: string;
920
- description: string;
921
- imageUrl: string;
922
- imageAlt: string;
923
- imageBgClass: string;
924
- imageAlign: 'left' | 'right';
1287
+ icon: string;
1288
+ iconBgClass: string;
1289
+ iconColorClass: string;
1290
+ title: string;
1291
+ description: string;
1292
+ imageUrl: string;
1293
+ imageAlt: string;
1294
+ imageBgClass: string;
1295
+ imageAlign: 'left' | 'right';
925
1296
  }
926
1297
  interface HelixPricingPlan {
927
- title: string;
928
- price: string;
929
- pricePeriod: string;
930
- imageUrl: string;
931
- imageAlt: string;
932
- buttonLabel: string;
933
- features: string[];
934
- }
935
-
936
- declare class HelixFeaturesWidget {
937
- sectionTitle: _angular_core.InputSignal<string>;
938
- sectionSubtitle: _angular_core.InputSignal<string>;
939
- features: _angular_core.InputSignal<HelixFeature[]>;
940
- testimonial: _angular_core.InputSignal<HelixTestimonial | null>;
941
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFeaturesWidget, never>;
942
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixFeaturesWidget, "helix-features-widget", never, { "sectionTitle": { "alias": "sectionTitle"; "required": false; "isSignal": true; }; "sectionSubtitle": { "alias": "sectionSubtitle"; "required": false; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "testimonial": { "alias": "testimonial"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
943
- }
944
-
945
- declare class HelixFooterWidget {
946
- columns: _angular_core.InputSignal<HelixFooterColumn[]>;
947
- homeRoute: _angular_core.InputSignal<string>;
948
- brandName: _angular_core.InputSignal<string>;
949
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFooterWidget, never>;
950
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixFooterWidget, "helix-footer-widget", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "homeRoute": { "alias": "homeRoute"; "required": false; "isSignal": true; }; "brandName": { "alias": "brandName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
951
- }
952
-
953
- declare class HelixHeroWidget {
954
- headlineLight: _angular_core.InputSignal<string>;
955
- headline: _angular_core.InputSignal<string>;
956
- description: _angular_core.InputSignal<string>;
957
- buttonLabel: _angular_core.InputSignal<string>;
958
- imageUrl: _angular_core.InputSignal<string>;
959
- imageAlt: _angular_core.InputSignal<string>;
960
- buttonClick: _angular_core.OutputEmitterRef<void>;
961
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixHeroWidget, never>;
962
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixHeroWidget, "helix-hero-widget", never, { "headlineLight": { "alias": "headlineLight"; "required": false; "isSignal": true; }; "headline": { "alias": "headline"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "imageAlt": { "alias": "imageAlt"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
963
- }
964
-
965
- declare class HelixHighlightsWidget {
966
- sectionTitle: _angular_core.InputSignal<string>;
967
- sectionSubtitle: _angular_core.InputSignal<string>;
968
- highlights: _angular_core.InputSignal<HelixHighlight[]>;
969
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixHighlightsWidget, never>;
970
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixHighlightsWidget, "helix-highlights-widget", never, { "sectionTitle": { "alias": "sectionTitle"; "required": false; "isSignal": true; }; "sectionSubtitle": { "alias": "sectionSubtitle"; "required": false; "isSignal": true; }; "highlights": { "alias": "highlights"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
971
- }
972
-
973
- declare class HelixPricingWidget {
974
- sectionTitle: _angular_core.InputSignal<string>;
975
- sectionSubtitle: _angular_core.InputSignal<string>;
976
- plans: _angular_core.InputSignal<HelixPricingPlan[]>;
977
- planSelect: _angular_core.OutputEmitterRef<HelixPricingPlan>;
978
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixPricingWidget, never>;
979
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixPricingWidget, "helix-pricing-widget", never, { "sectionTitle": { "alias": "sectionTitle"; "required": false; "isSignal": true; }; "sectionSubtitle": { "alias": "sectionSubtitle"; "required": false; "isSignal": true; }; "plans": { "alias": "plans"; "required": false; "isSignal": true; }; }, { "planSelect": "planSelect"; }, never, never, true, never>;
980
- }
981
-
982
- declare class HelixTopbarWidget {
983
- router: Router;
984
- navLinks: _angular_core.InputSignal<HelixNavLink[]>;
985
- loginLabel: _angular_core.InputSignal<string>;
986
- loginRoute: _angular_core.InputSignal<string>;
987
- registerLabel: _angular_core.InputSignal<string>;
988
- registerRoute: _angular_core.InputSignal<string>;
989
- constructor(router: Router);
990
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixTopbarWidget, never>;
991
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixTopbarWidget, "helix-topbar-widget", never, { "navLinks": { "alias": "navLinks"; "required": false; "isSignal": true; }; "loginLabel": { "alias": "loginLabel"; "required": false; "isSignal": true; }; "loginRoute": { "alias": "loginRoute"; "required": false; "isSignal": true; }; "registerLabel": { "alias": "registerLabel"; "required": false; "isSignal": true; }; "registerRoute": { "alias": "registerRoute"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
992
- }
993
-
994
- declare class HelixLanding {
995
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixLanding, never>;
996
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixLanding, "helix-landing", never, {}, {}, never, never, true, never>;
997
- }
998
-
1298
+ title: string;
1299
+ price: string;
1300
+ pricePeriod: string;
1301
+ imageUrl: string;
1302
+ imageAlt: string;
1303
+ buttonLabel: string;
1304
+ features: string[];
1305
+ }
1306
+ export declare class HelixFeaturesWidget {
1307
+ sectionTitle: import("@angular/core").InputSignal<string>;
1308
+ sectionSubtitle: import("@angular/core").InputSignal<string>;
1309
+ features: import("@angular/core").InputSignal<HelixFeature[]>;
1310
+ testimonial: import("@angular/core").InputSignal<HelixTestimonial | null>;
1311
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixFeaturesWidget, never>;
1312
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixFeaturesWidget, "helix-features-widget", never, {
1313
+ "sectionTitle": {
1314
+ "alias": "sectionTitle";
1315
+ "required": false;
1316
+ "isSignal": true;
1317
+ };
1318
+ "sectionSubtitle": {
1319
+ "alias": "sectionSubtitle";
1320
+ "required": false;
1321
+ "isSignal": true;
1322
+ };
1323
+ "features": {
1324
+ "alias": "features";
1325
+ "required": false;
1326
+ "isSignal": true;
1327
+ };
1328
+ "testimonial": {
1329
+ "alias": "testimonial";
1330
+ "required": false;
1331
+ "isSignal": true;
1332
+ };
1333
+ }, {}, never, never, true, never>;
1334
+ }
1335
+ export declare class HelixFooterWidget {
1336
+ columns: import("@angular/core").InputSignal<HelixFooterColumn[]>;
1337
+ homeRoute: import("@angular/core").InputSignal<string>;
1338
+ brandName: import("@angular/core").InputSignal<string>;
1339
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixFooterWidget, never>;
1340
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixFooterWidget, "helix-footer-widget", never, {
1341
+ "columns": {
1342
+ "alias": "columns";
1343
+ "required": false;
1344
+ "isSignal": true;
1345
+ };
1346
+ "homeRoute": {
1347
+ "alias": "homeRoute";
1348
+ "required": false;
1349
+ "isSignal": true;
1350
+ };
1351
+ "brandName": {
1352
+ "alias": "brandName";
1353
+ "required": false;
1354
+ "isSignal": true;
1355
+ };
1356
+ }, {}, never, never, true, never>;
1357
+ }
1358
+ export declare class HelixHeroWidget {
1359
+ headlineLight: import("@angular/core").InputSignal<string>;
1360
+ headline: import("@angular/core").InputSignal<string>;
1361
+ description: import("@angular/core").InputSignal<string>;
1362
+ buttonLabel: import("@angular/core").InputSignal<string>;
1363
+ imageUrl: import("@angular/core").InputSignal<string>;
1364
+ imageAlt: import("@angular/core").InputSignal<string>;
1365
+ buttonClick: import("@angular/core").OutputEmitterRef<void>;
1366
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixHeroWidget, never>;
1367
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixHeroWidget, "helix-hero-widget", never, {
1368
+ "headlineLight": {
1369
+ "alias": "headlineLight";
1370
+ "required": false;
1371
+ "isSignal": true;
1372
+ };
1373
+ "headline": {
1374
+ "alias": "headline";
1375
+ "required": false;
1376
+ "isSignal": true;
1377
+ };
1378
+ "description": {
1379
+ "alias": "description";
1380
+ "required": false;
1381
+ "isSignal": true;
1382
+ };
1383
+ "buttonLabel": {
1384
+ "alias": "buttonLabel";
1385
+ "required": false;
1386
+ "isSignal": true;
1387
+ };
1388
+ "imageUrl": {
1389
+ "alias": "imageUrl";
1390
+ "required": false;
1391
+ "isSignal": true;
1392
+ };
1393
+ "imageAlt": {
1394
+ "alias": "imageAlt";
1395
+ "required": false;
1396
+ "isSignal": true;
1397
+ };
1398
+ }, {
1399
+ "buttonClick": "buttonClick";
1400
+ }, never, never, true, never>;
1401
+ }
1402
+ export declare class HelixHighlightsWidget {
1403
+ sectionTitle: import("@angular/core").InputSignal<string>;
1404
+ sectionSubtitle: import("@angular/core").InputSignal<string>;
1405
+ highlights: import("@angular/core").InputSignal<HelixHighlight[]>;
1406
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixHighlightsWidget, never>;
1407
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixHighlightsWidget, "helix-highlights-widget", never, {
1408
+ "sectionTitle": {
1409
+ "alias": "sectionTitle";
1410
+ "required": false;
1411
+ "isSignal": true;
1412
+ };
1413
+ "sectionSubtitle": {
1414
+ "alias": "sectionSubtitle";
1415
+ "required": false;
1416
+ "isSignal": true;
1417
+ };
1418
+ "highlights": {
1419
+ "alias": "highlights";
1420
+ "required": false;
1421
+ "isSignal": true;
1422
+ };
1423
+ }, {}, never, never, true, never>;
1424
+ }
1425
+ export declare class HelixPricingWidget {
1426
+ sectionTitle: import("@angular/core").InputSignal<string>;
1427
+ sectionSubtitle: import("@angular/core").InputSignal<string>;
1428
+ plans: import("@angular/core").InputSignal<HelixPricingPlan[]>;
1429
+ planSelect: import("@angular/core").OutputEmitterRef<HelixPricingPlan>;
1430
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixPricingWidget, never>;
1431
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixPricingWidget, "helix-pricing-widget", never, {
1432
+ "sectionTitle": {
1433
+ "alias": "sectionTitle";
1434
+ "required": false;
1435
+ "isSignal": true;
1436
+ };
1437
+ "sectionSubtitle": {
1438
+ "alias": "sectionSubtitle";
1439
+ "required": false;
1440
+ "isSignal": true;
1441
+ };
1442
+ "plans": {
1443
+ "alias": "plans";
1444
+ "required": false;
1445
+ "isSignal": true;
1446
+ };
1447
+ }, {
1448
+ "planSelect": "planSelect";
1449
+ }, never, never, true, never>;
1450
+ }
1451
+ export declare class HelixTopbarWidget {
1452
+ router: Router;
1453
+ navLinks: import("@angular/core").InputSignal<HelixNavLink[]>;
1454
+ loginLabel: import("@angular/core").InputSignal<string>;
1455
+ loginRoute: import("@angular/core").InputSignal<string>;
1456
+ registerLabel: import("@angular/core").InputSignal<string>;
1457
+ registerRoute: import("@angular/core").InputSignal<string>;
1458
+ constructor(router: Router);
1459
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixTopbarWidget, never>;
1460
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixTopbarWidget, "helix-topbar-widget", never, {
1461
+ "navLinks": {
1462
+ "alias": "navLinks";
1463
+ "required": false;
1464
+ "isSignal": true;
1465
+ };
1466
+ "loginLabel": {
1467
+ "alias": "loginLabel";
1468
+ "required": false;
1469
+ "isSignal": true;
1470
+ };
1471
+ "loginRoute": {
1472
+ "alias": "loginRoute";
1473
+ "required": false;
1474
+ "isSignal": true;
1475
+ };
1476
+ "registerLabel": {
1477
+ "alias": "registerLabel";
1478
+ "required": false;
1479
+ "isSignal": true;
1480
+ };
1481
+ "registerRoute": {
1482
+ "alias": "registerRoute";
1483
+ "required": false;
1484
+ "isSignal": true;
1485
+ };
1486
+ }, {}, never, never, true, never>;
1487
+ }
1488
+ export declare class HelixLanding {
1489
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixLanding, never>;
1490
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixLanding, "helix-landing", never, {}, {}, never, never, true, never>;
1491
+ }
999
1492
  interface HelixNotfoundSuggestion {
1000
- icon: string;
1001
- title: string;
1002
- description: string;
1003
- route: string;
1004
- }
1005
- declare class HelixNotfound {
1006
- errorCode: _angular_core.InputSignal<string>;
1007
- title: _angular_core.InputSignal<string>;
1008
- message: _angular_core.InputSignal<string>;
1009
- buttonLabel: _angular_core.InputSignal<string>;
1010
- buttonRoute: _angular_core.InputSignal<string>;
1011
- suggestions: _angular_core.InputSignal<HelixNotfoundSuggestion[]>;
1012
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixNotfound, never>;
1013
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixNotfound, "helix-notfound", never, { "errorCode": { "alias": "errorCode"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "buttonRoute": { "alias": "buttonRoute"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
1014
- }
1015
-
1016
- export { HELIX_BREADCRUMB, HelixAccess, HelixAlertAction, HelixAppLayout, HelixBadge, HelixConfigurator, HelixConfiguratorAction, HelixDarkModeAction, HelixEmpty, HelixEnvironmentBadge, HelixError, HelixFeaturesWidget, HelixFloatingConfigurator, HelixFooter, HelixFooterWidget, HelixFormField, HelixHeroWidget, HelixHighlightsWidget, HelixLanding, HelixLogin, HelixMobileMenuAction, HelixNavRail, HelixNavRailItem, HelixNotfound, HelixPricingWidget, HelixSelect, HelixStatusBar, HelixTopbar, HelixTopbarWidget, LayoutStore, authRoutes, helixBreadcrumbsFromRoutes, helixMenuLinksFrom, helixNavGroupsFromMenu, helixRoutesFrom };
1017
- export type { AlertItem, BadgeSeverity, Environment, HelixBreadcrumb, HelixFeature, HelixFooterColumn, HelixFooterLink, HelixHighlight, HelixLoginCredentials, HelixNavGroup, HelixNavLink, HelixNotfoundSuggestion, HelixPricingPlan, HelixRouteMenuItem, HelixStatusBarTone, HelixStatusBarVersion, HelixTestimonial, HelixTopbarAction, HelixTopbarItem, HelixTopbarItemType, LayoutConfig, LayoutState, MenuMode };
1493
+ icon: string;
1494
+ title: string;
1495
+ description: string;
1496
+ route: string;
1497
+ }
1498
+ export declare class HelixNotfound {
1499
+ errorCode: import("@angular/core").InputSignal<string>;
1500
+ title: import("@angular/core").InputSignal<string>;
1501
+ message: import("@angular/core").InputSignal<string>;
1502
+ buttonLabel: import("@angular/core").InputSignal<string>;
1503
+ buttonRoute: import("@angular/core").InputSignal<string>;
1504
+ suggestions: import("@angular/core").InputSignal<HelixNotfoundSuggestion[]>;
1505
+ static ɵfac: i0.ɵɵFactoryDeclaration<HelixNotfound, never>;
1506
+ static ɵcmp: i0.ɵɵComponentDeclaration<HelixNotfound, "helix-notfound", never, {
1507
+ "errorCode": {
1508
+ "alias": "errorCode";
1509
+ "required": false;
1510
+ "isSignal": true;
1511
+ };
1512
+ "title": {
1513
+ "alias": "title";
1514
+ "required": false;
1515
+ "isSignal": true;
1516
+ };
1517
+ "message": {
1518
+ "alias": "message";
1519
+ "required": false;
1520
+ "isSignal": true;
1521
+ };
1522
+ "buttonLabel": {
1523
+ "alias": "buttonLabel";
1524
+ "required": false;
1525
+ "isSignal": true;
1526
+ };
1527
+ "buttonRoute": {
1528
+ "alias": "buttonRoute";
1529
+ "required": false;
1530
+ "isSignal": true;
1531
+ };
1532
+ "suggestions": {
1533
+ "alias": "suggestions";
1534
+ "required": false;
1535
+ "isSignal": true;
1536
+ };
1537
+ }, {}, never, never, true, never>;
1538
+ }
1539
+ export type { AlertItem, BadgeSeverity, Environment, HelixBreadcrumb, HelixFeature, HelixFooterColumn, HelixFooterLink, HelixHighlight, HelixLoginCredentials, HelixNavGroup, HelixNavLink, HelixNavStyle, HelixNotfoundSuggestion, HelixPricingPlan, HelixRouteMenuItem, HelixStatusBarTone, HelixStatusBarVersion, HelixTestimonial, HelixTopbarAction, HelixTopbarItem, HelixTopbarItemType };