@nucleus-suite-pe/core 0.7.0 → 1.1.0

package/types/nucleus-suite-pe-core.d.ts

@@ -1,9 +1,10 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, EnvironmentProviders, Signal, TemplateRef } from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Signal, ElementRef, TemplateRef } from '@angular/core';
 import { HttpContextToken, HttpInterceptorFn } from '@angular/common/http';
 import * as _nucleus_suite_pe_core from '@nucleus-suite-pe/core';
 import * as _primeuix_themes from '@primeuix/themes';
 import * as _primeuix_themes_types_base from '@primeuix/themes/types/base';
+import { Popover } from 'primeng/popover';
 import { MenuItem } from 'primeng/api';
 
 interface NucleusConfig {
@@ -125,6 +126,11 @@ interface CompanySummary {
     readonly createdAtUtc: string;
     readonly myAccess: readonly SiteAccess[];
 }
+interface GlobalAccess {
+    readonly appId: string;
+    readonly appName: string;
+    readonly roleName: string;
+}
 interface UserProfile {
     readonly firstName: string | null;
     readonly lastName: string | null;
@@ -175,6 +181,7 @@ interface MeResponse {
     readonly subscription: Subscription;
     readonly ownedCompanies: readonly CompanySummary[];
     readonly sharedCompanies: readonly CompanySummary[];
+    readonly globalAccess: readonly GlobalAccess[];
 }
 type AccessScope = 'site' | 'account';
 interface AppSummary {
@@ -189,6 +196,19 @@ interface AppSummary {
 }
 type LauncherApp = AppSummary;
 
+declare function nucleusErrorMessage(error: unknown, lang?: string): string;
+
+declare class NucleusCache {
+    private readonly entries;
+    private readonly inFlight;
+    read<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    prefetch<T>(key: string, loader: () => Promise<T>, ttlMs?: number): void;
+    invalidate(...prefixes: readonly string[]): void;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusCache, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NucleusCache>;
+}
+
 interface MenuPermissions {
     readonly canView: boolean;
     readonly canInsert: boolean;
@@ -209,8 +229,10 @@ declare class SessionService {
     private readonly _me;
     private readonly _menu;
     private readonly _access;
+    private readonly _globalRole;
     private readonly _scope;
     private readonly _apps;
+    private readonly _catalog;
     private readonly _siteId;
     private readonly _loading;
     private readonly _switching;
@@ -223,6 +245,8 @@ declare class SessionService {
     readonly access: _angular_core.Signal<SiteAccess | null>;
     readonly scope: _angular_core.Signal<AccessScope | null>;
     readonly apps: _angular_core.Signal<readonly AppSummary[]>;
+    readonly catalog: _angular_core.Signal<readonly AppSummary[]>;
+    readonly currentApp: _angular_core.Signal<AppSummary | null>;
     readonly siteId: _angular_core.Signal<string | null>;
     readonly loading: _angular_core.Signal<boolean>;
     readonly switching: _angular_core.Signal<boolean>;
@@ -234,6 +258,7 @@ declare class SessionService {
     readonly companyId: _angular_core.Signal<string | null>;
     readonly companyName: _angular_core.Signal<string | null>;
     load(language: string, force?: boolean): Promise<void>;
+    signOutToLanding(): Promise<void>;
     permissionsFor(route: string): MenuPermissions;
     reload(language: string): Promise<void>;
     sites(companyId: string): Promise<Site[]>;
@@ -249,6 +274,7 @@ declare class SessionService {
 
 type NucleusLang = 'es' | 'en';
 declare const NUCLEUS_LANGS: readonly NucleusLang[];
+declare function nucleusLang(): NucleusLang;
 declare class NucleusLanguage {
     private readonly _lang;
     readonly lang: _angular_core.Signal<NucleusLang>;
@@ -258,6 +284,102 @@ declare class NucleusLanguage {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NucleusLanguage>;
 }
 
+interface CommonCopy {
+    readonly search: string;
+    readonly choose: string;
+    readonly noIcon: string;
+    readonly noColor: string;
+    readonly searchIcon: string;
+    readonly noMatches: string;
+    readonly sessionExpired: string;
+    readonly errorNetwork: string;
+    readonly errorTimeout: string;
+    readonly errorServer: string;
+    readonly errorInvalid: string;
+    readonly errorForbidden: string;
+    readonly errorNotFound: string;
+    readonly errorConflict: string;
+    readonly errorUnknown: string;
+}
+interface CommonCopySet {
+    readonly es: CommonCopy;
+    readonly en: CommonCopy;
+}
+declare const COMMON_COPY: CommonCopySet;
+declare function commonCopyOf(lang: string): CommonCopy;
+
+declare function nucleusParseDate(value: string | null | undefined): Date | null;
+declare function money(value: number | null | undefined): string;
+declare function signedMoney(value: number | null | undefined): string;
+declare function qty(value: number | null | undefined): string;
+declare function integer(value: number | null | undefined): string;
+declare function percent(value: number | null | undefined): string;
+declare function day(value: string | null | undefined): string;
+declare function stamp(value: string | null | undefined): string;
+declare function clock(value: string | null | undefined): string;
+declare function minutesAsClock(value: number | null | undefined): string;
+declare function isoDay(value: Date | string | null | undefined): string;
+declare function toNumber(value: unknown): number;
+declare function shiftDay(value: string, days: number): string;
+declare function isToday(value: string | null | undefined): boolean;
+declare function isBeforeToday(value: string | null | undefined): boolean;
+declare function isOnOrBeforeToday(value: string | null | undefined): boolean;
+declare function startOfDayUtc(value: string): string;
+declare function endOfDayUtc(value: string): string;
+
+declare const FIELD_TARGETS: string;
+declare function isReachable(element: HTMLElement): boolean;
+declare function fieldsIn(root: HTMLElement): HTMLElement[];
+declare function moveTo(element: HTMLElement): void;
+
+interface ShortcutBinding {
+    readonly keys: string;
+    readonly label: string;
+    readonly whileTyping: boolean;
+    readonly run: () => void;
+}
+declare function normalizeKeys(keys: string): string;
+declare function comboOf(event: KeyboardEvent): string;
+declare function hasModifier(keys: string): boolean;
+declare function isTypingTarget(target: EventTarget | null): boolean;
+declare function isApplePlatform(): boolean;
+declare function shortcutHint(keys: string): string;
+declare function ariaKeysOf(keys: string): string;
+
+declare class NucleusShortcuts {
+    private readonly document;
+    private readonly _bindings;
+    private readonly _enabled;
+    readonly bindings: _angular_core.Signal<readonly ShortcutBinding[]>;
+    readonly enabled: _angular_core.Signal<boolean>;
+    constructor();
+    setEnabled(enabled: boolean): void;
+    register(binding: ShortcutBinding): () => void;
+    private handle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusShortcuts, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NucleusShortcuts>;
+}
+
+declare class NucleusShortcut {
+    private readonly host;
+    private readonly shortcuts;
+    readonly nucleusShortcut: _angular_core.InputSignal<string>;
+    readonly shortcutLabel: _angular_core.InputSignal<string>;
+    readonly shortcutWhileTyping: _angular_core.InputSignal<boolean | null>;
+    constructor();
+    private press;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusShortcut, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NucleusShortcut, "[nucleusShortcut]", never, { "nucleusShortcut": { "alias": "nucleusShortcut"; "required": true; "isSignal": true; }; "shortcutLabel": { "alias": "shortcutLabel"; "required": false; "isSignal": true; }; "shortcutWhileTyping": { "alias": "shortcutWhileTyping"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NucleusEnterAdvance {
+    private readonly host;
+    onKeyDown(event: KeyboardEvent): void;
+    private scope;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusEnterAdvance, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NucleusEnterAdvance, "[nucleusEnterAdvance]", never, {}, {}, never, never, true, never>;
+}
+
 interface GeoCountry {
     readonly id: string;
     readonly code: string;
@@ -293,8 +415,6 @@ declare function flagOf(code: string): string;
 
 interface GeoCopy {
     readonly country: string;
-    readonly choose: string;
-    readonly search: string;
     readonly levels: readonly [string, string, string, string];
     readonly kinds: Readonly<Record<string, string>>;
 }
@@ -334,6 +454,7 @@ declare class NucleusGeoSelect {
     protected readonly countries: _angular_core.WritableSignal<GeoCountry[]>;
     protected readonly steps: _angular_core.WritableSignal<GeoStep[]>;
     protected readonly labels: _angular_core.Signal<_nucleus_suite_pe_core.GeoCopy>;
+    protected readonly words: _angular_core.Signal<_nucleus_suite_pe_core.CommonCopy>;
     private syncedKey;
     constructor();
     protected gridClass(): string;
@@ -342,42 +463,142 @@ declare class NucleusGeoSelect {
     protected pick(index: number, divisionId: string | null): Promise<void>;
     private sync;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusGeoSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusGeoSelect, "nucleus-geo-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusGeoSelect, "nucleus-geo-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof NucleusEnterAdvance; inputs: {}; outputs: {}; }]>;
 }
 
-type ThemeId = 'nucleus' | 'light' | 'dark' | 'bubblegum' | 'cool-breeze' | 'cool-slate' | 'icy-mint' | 'juicy-plum' | 'mango-paradise' | 'moonlight-glow' | 'mystical-forest' | 'silky-pink' | 'spicy-red' | 'sunny-day';
-type ThemePreference = ThemeId | 'system';
-interface ThemeTokens {
+declare const TEXT_CONTRAST = 4.5;
+declare const CONTROL_CONTRAST = 3;
+interface ContrastIssue {
+    readonly scope: string;
+    readonly pair: string;
+    readonly ratio: number;
+    readonly required: number;
+}
+declare function relativeLuminance(hex: string): number;
+declare function contrastRatio(foreground: string, background: string): number;
+declare function readableOn(background: string): string;
+declare function mixHex(foreground: string, background: string, ratio: number): string;
+declare function meetsContrast(foreground: string, background: string, required: number): boolean;
+declare function contrastIssue(scope: string, pair: string, foreground: string, background: string, required: number): ContrastIssue | null;
+
+type FrameId = 'nucleus' | 'ember' | 'forest' | 'plum' | 'midnight' | 'slate' | 'ocean' | 'sand' | 'ink' | 'graphite' | 'paper' | 'mist';
+type CanvasId = 'light' | 'dim' | 'dark';
+type CanvasPreference = CanvasId | 'system';
+type AccentId = 'violet' | 'blue' | 'cyan' | 'green' | 'lime' | 'amber' | 'orange' | 'rose' | 'red';
+type AccentPreference = AccentId | 'auto';
+type DensityId = 'comfortable' | 'compact';
+interface FrameTokens {
+    readonly bg: string;
+    readonly raised: string;
+    readonly ink: string;
+    readonly muted: string;
+    readonly line: string;
+    readonly glow: string;
+}
+interface Frame {
+    readonly id: FrameId;
+    readonly scheme: CanvasId;
+    readonly starfield: boolean;
+    readonly accent: AccentId;
+    readonly tokens: FrameTokens;
+}
+interface CanvasTokens {
     readonly bg: string;
     readonly surface: string;
     readonly surfaceAlt: string;
     readonly text: string;
     readonly textMuted: string;
     readonly border: string;
-    readonly accent: string;
-    readonly onAccent: string;
 }
-interface Theme {
-    readonly id: ThemeId;
-    readonly scheme: 'light' | 'dark';
-    readonly swatch: string;
-    readonly starfield: boolean;
-    readonly tokens: ThemeTokens;
+interface CanvasEffects {
+    readonly shadowOne: string;
+    readonly shadowTwo: string;
+    readonly wash: number;
+    readonly washStrong: number;
+    readonly headerBg: string;
+    readonly headerInk: string;
+    readonly headerLine: string;
+    readonly danger: string;
+    readonly success: string;
+    readonly warning: string;
+}
+interface Canvas {
+    readonly id: CanvasId;
+    readonly tokens: CanvasTokens;
+    readonly effects: CanvasEffects;
+}
+interface Accent {
+    readonly id: AccentId;
+    readonly light: string;
+    readonly dark: string;
 }
-declare const THEMES: readonly Theme[];
-declare const THEME_LABELS: Readonly<Record<ThemeId, string>>;
-declare const DEFAULT_THEME: ThemeId;
-declare function themeById(id: ThemeId): Theme;
-declare function isThemePreference(value: unknown): value is ThemePreference;
+interface Density {
+    readonly id: DensityId;
+    readonly scale: number;
+}
+interface Appearance {
+    readonly frame: FrameId;
+    readonly canvas: CanvasPreference;
+    readonly accent: AccentPreference;
+    readonly density: DensityId;
+}
+declare const FRAMES: readonly Frame[];
+declare const CANVASES: readonly Canvas[];
+declare const ACCENTS: readonly Accent[];
+declare const DENSITIES: readonly Density[];
+declare const DEFAULT_APPEARANCE: Appearance;
+declare const LEGACY_THEMES: Readonly<Record<string, Partial<Appearance>>>;
+declare function frameById(id: string): Frame;
+declare function canvasById(id: CanvasId): Canvas;
+declare function accentById(id: string): Accent;
+declare function densityById(id: string): Density;
+declare function isFrameId(value: unknown): value is FrameId;
+declare function isCanvasPreference(value: unknown): value is CanvasPreference;
+declare function isAccentPreference(value: unknown): value is AccentPreference;
+declare function isDensityId(value: unknown): value is DensityId;
+declare function resolveAccent(frame: Frame, preference: AccentPreference): Accent;
+declare function accentOn(accent: Accent, canvas: CanvasId): string;
+declare function isDarkCanvas(canvas: CanvasId): boolean;
+declare function auditAppearance(): readonly ContrastIssue[];
+
+interface ThemeCopy {
+    readonly title: string;
+    readonly frameTitle: string;
+    readonly frameHint: string;
+    readonly canvasTitle: string;
+    readonly canvasHint: string;
+    readonly accentTitle: string;
+    readonly accentHint: string;
+    readonly densityTitle: string;
+    readonly densityHint: string;
+    readonly frames: Readonly<Record<FrameId, string>>;
+    readonly canvases: Readonly<Record<CanvasPreference, string>>;
+    readonly accents: Readonly<Record<AccentPreference, string>>;
+    readonly densities: Readonly<Record<DensityId, string>>;
+}
+declare const THEME_COPY: Readonly<Record<NucleusLang, ThemeCopy>>;
+declare function themeCopyOf(lang: NucleusLang): ThemeCopy;
+declare function accentLabelOf(lang: NucleusLang, id: AccentId): string;
 
 declare class ThemeService {
-    private readonly _preference;
+    private readonly _appearance;
     private readonly systemDark;
-    readonly preference: _angular_core.Signal<ThemePreference>;
-    readonly theme: _angular_core.Signal<Theme>;
+    readonly appearance: _angular_core.Signal<Appearance>;
+    readonly frame: _angular_core.Signal<Frame>;
+    readonly canvasId: _angular_core.Signal<CanvasId>;
+    readonly systemCanvasId: _angular_core.Signal<CanvasId>;
+    readonly canvas: _angular_core.Signal<Canvas>;
+    readonly accent: _angular_core.Signal<Accent>;
+    readonly accentColor: _angular_core.Signal<string>;
+    readonly density: _angular_core.Signal<Density>;
     readonly starfield: _angular_core.Signal<boolean>;
     constructor();
-    setPreference(preference: ThemePreference): void;
+    setFrame(frame: FrameId): void;
+    setCanvas(canvas: CanvasPreference): void;
+    setAccent(accent: AccentPreference): void;
+    setDensity(density: DensityId): void;
+    reset(): void;
+    private patch;
     private applyToDom;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
@@ -415,8 +636,36 @@ declare class NucleusCard {
     readonly heading: _angular_core.InputSignal<string>;
     readonly subtitle: _angular_core.InputSignal<string>;
     readonly size: _angular_core.InputSignal<CardSize>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly skeletonRows: _angular_core.InputSignal<number>;
+    private static readonly widths;
+    protected readonly placeholders: _angular_core.Signal<{
+        index: number;
+        left: string;
+        right: string;
+    }[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusCard, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusCard, "nucleus-card", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[nucleusCardActions]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusCard, "nucleus-card", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[nucleusCardActions]"], true, never>;
+}
+
+declare class NucleusMetrics {
+    readonly loading: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusMetrics, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusMetrics, "nucleus-metrics", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type MetricTone = 'plain' | 'accent';
+declare class NucleusMetric {
+    private readonly group;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly hint: _angular_core.InputSignal<string>;
+    readonly link: _angular_core.InputSignal<string | unknown[]>;
+    readonly tone: _angular_core.InputSignal<MetricTone>;
+    readonly loading: _angular_core.InputSignal<boolean | null>;
+    protected readonly busy: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusMetric, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusMetric, "nucleus-metric", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface TabItem {
@@ -464,7 +713,7 @@ declare class NucleusFeedback {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NucleusFeedback>;
 }
 
-type FieldKind = 'text' | 'email' | 'password' | 'number' | 'textarea' | 'select' | 'checkbox' | 'switch';
+type FieldKind = 'text' | 'email' | 'password' | 'number' | 'textarea' | 'select' | 'checkbox' | 'switch' | 'icon' | 'color';
 type FieldSpan = 1 | 2 | 3 | 4 | 'full';
 type FieldSize = 'xs' | 'sm' | 'md' | 'lg' | 'full';
 interface FieldOption {
@@ -484,27 +733,82 @@ interface FormField {
     readonly options?: readonly FieldOption[];
     readonly disabled?: boolean;
     readonly clearable?: boolean;
+    readonly searchable?: boolean;
 }
 type FormValue = Record<string, unknown>;
 declare function resolveFieldSize(field: FormField): FieldSize;
+declare function isFieldSearchable(field: FormField): boolean;
+
+declare const NUCLEUS_ICON_CATALOG: readonly string[];
+declare function searchIcons(term: string): readonly string[];
+declare function iconClassOf(name: string | null): string;
+declare function iconNameOf(value: string | null): string | null;
+
+declare class NucleusIconPicker {
+    private readonly language;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    protected readonly panel: _angular_core.Signal<Popover>;
+    protected readonly search: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly term: _angular_core.WritableSignal<string>;
+    protected readonly labels: _angular_core.Signal<_nucleus_suite_pe_core.CommonCopy>;
+    protected readonly name: _angular_core.Signal<string | null>;
+    protected readonly iconClass: _angular_core.Signal<string>;
+    protected readonly results: _angular_core.Signal<readonly string[]>;
+    protected onShow(): void;
+    protected pick(icon: string | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusIconPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusIconPicker, "nucleus-icon-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+interface AccentOption {
+    readonly id: AccentId;
+    readonly light: string;
+    readonly dark: string;
+}
+declare const NUCLEUS_ACCENTS: readonly AccentOption[];
+declare class NucleusColorPicker {
+    private readonly language;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly labels: _angular_core.Signal<_nucleus_suite_pe_core.CommonCopy>;
+    protected readonly options: _angular_core.Signal<{
+        color: string;
+        label: string;
+    }[]>;
+    protected pick(color: string | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusColorPicker, "nucleus-color-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
 
 declare class NucleusForm {
+    private readonly language;
+    private readonly host;
+    private readonly injector;
     readonly fields: _angular_core.InputSignal<readonly FormField[]>;
     readonly value: _angular_core.InputSignal<FormValue>;
     readonly readonly: _angular_core.InputSignal<boolean>;
     readonly columns: _angular_core.InputSignal<number | null>;
+    readonly autofocus: _angular_core.InputSignal<boolean>;
     readonly valueChange: _angular_core.OutputEmitterRef<FormValue>;
+    protected readonly labels: _angular_core.Signal<_nucleus_suite_pe_core.CommonCopy>;
+    private landed;
+    constructor();
     protected read(field: FormField): unknown;
     protected text(field: FormField): string;
+    protected nullableText(field: FormField): string | null;
     protected checked(field: FormField): boolean;
     protected write(field: FormField, next: unknown): void;
     protected isDisabled(field: FormField): boolean;
+    protected isSearchable(field: FormField): boolean;
     protected fieldClass(field: FormField): string;
     protected gridClass(): string;
     protected optionsOf(field: FormField): FieldOption[];
     protected kindOf(field: FormField): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusForm, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusForm, "nucleus-form", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusForm, "nucleus-form", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, [{ directive: typeof NucleusEnterAdvance; inputs: {}; outputs: {}; }]>;
 }
 
 type ListAlign = 'left' | 'center' | 'right';
@@ -532,6 +836,7 @@ interface ListAction<T = Record<string, unknown>> {
     readonly label: string;
     readonly tone?: 'default' | 'danger';
     readonly visible?: (row: T) => boolean;
+    readonly disabled?: (row: T) => boolean;
 }
 interface ListActionEvent<T = Record<string, unknown>> {
     readonly id: string;
@@ -557,6 +862,7 @@ declare class NucleusList<T extends object = Record<string, unknown>> {
     readonly empty: _angular_core.InputSignal<string>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly minWidth: _angular_core.InputSignal<string>;
+    readonly skeletonRows: _angular_core.InputSignal<number>;
     readonly rowClass: _angular_core.InputSignal<(row: T) => string>;
     readonly action: _angular_core.OutputEmitterRef<ListActionEvent<T>>;
     readonly toggle: _angular_core.OutputEmitterRef<ListToggleEvent<T>>;
@@ -565,18 +871,30 @@ declare class NucleusList<T extends object = Record<string, unknown>> {
         'min-width': string;
     }>;
     protected readonly showEmpty: _angular_core.Signal<boolean>;
+    protected readonly placeholders: _angular_core.Signal<object[]>;
+    protected readonly data: _angular_core.Signal<object[]>;
+    protected skeletonWidth(column: ListColumn<T>): string;
     protected cellTemplate(key: string): TemplateRef<unknown> | null;
     protected text(column: ListColumn<T>, row: T): string;
     protected tagOf(column: ListColumn<T>, row: T): ListTag | null;
     protected visibleActions(row: T): readonly ListAction<T>[];
+    protected isActionLocked(entry: ListAction<T>, row: T): boolean;
     protected run(entry: ListAction<T>, row: T): void;
     protected isChecked(column: ListColumn<T>, row: T): boolean;
     protected isLocked(column: ListColumn<T>, row: T): boolean;
     protected hintOf(column: ListColumn<T>, row: T): string;
     protected flip(column: ListColumn<T>, row: T): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusList<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusList<any>, "nucleus-list", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; }, { "action": "action"; "toggle": "toggle"; }, ["cells"], ["[nucleusListTitle]", "[nucleusListActions]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusList<any>, "nucleus-list", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; }, { "action": "action"; "toggle": "toggle"; }, ["cells"], ["[nucleusListTitle]", "[nucleusListActions]"], true, never>;
+}
+
+interface TreeRow {
+    readonly id: string;
+    readonly parentId: string | null;
 }
+declare function toggleCollapsed(collapsed: ReadonlySet<string>, id: string): ReadonlySet<string>;
+declare function hasChildren(rows: readonly TreeRow[], id: string): boolean;
+declare function visibleTreeRows<T extends TreeRow>(rows: readonly T[], collapsed: ReadonlySet<string>): T[];
 
 declare class NucleusMark {
     readonly accent: _angular_core.InputSignal<string>;
@@ -590,6 +908,119 @@ declare class NucleusMark {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusMark, "nucleus-mark", never, { "accent": { "alias": "accent"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+interface FrameChoice {
+    readonly id: Frame['id'];
+    readonly label: string;
+    readonly tokens: Frame['tokens'];
+}
+interface CanvasChoice {
+    readonly id: CanvasPreference;
+    readonly label: string;
+    readonly bg: string;
+    readonly surface: string;
+    readonly text: string;
+    readonly icon: string | null;
+}
+interface AccentChoice {
+    readonly id: AccentPreference;
+    readonly label: string;
+    readonly color: string;
+    readonly ink: string;
+}
+interface DensityChoice {
+    readonly id: DensityId;
+    readonly label: string;
+    readonly gap: number;
+}
+declare class NucleusAppearance {
+    private readonly theme;
+    private readonly language;
+    protected readonly copy: _angular_core.Signal<_nucleus_suite_pe_core.ThemeCopy>;
+    protected readonly appearance: _angular_core.Signal<_nucleus_suite_pe_core.Appearance>;
+    protected readonly canvasId: _angular_core.Signal<_nucleus_suite_pe_core.CanvasId>;
+    protected readonly frames: _angular_core.Signal<FrameChoice[]>;
+    protected readonly canvases: _angular_core.Signal<CanvasChoice[]>;
+    protected readonly accents: _angular_core.Signal<AccentChoice[]>;
+    protected readonly densities: _angular_core.Signal<DensityChoice[]>;
+    protected pickFrame(id: Frame['id']): void;
+    protected pickCanvas(id: CanvasPreference): void;
+    protected pickAccent(id: AccentPreference): void;
+    protected pickDensity(id: DensityId): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusAppearance, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusAppearance, "nucleus-appearance", never, {}, {}, never, never, true, never>;
+}
+
+interface MenuTile {
+    readonly label: string;
+    readonly icon: string | null;
+    readonly color: string | null;
+    readonly ink: string | null;
+    readonly ghost: boolean;
+}
+interface MenuRow {
+    readonly id: string;
+    readonly name: string;
+    readonly meta: string | null;
+    readonly tile: MenuTile | null;
+    readonly tag: string | null;
+    readonly current: boolean;
+    readonly disabled: boolean;
+}
+interface MenuSection {
+    readonly id: string;
+    readonly label: string | null;
+    readonly rows: readonly MenuRow[];
+}
+declare function menuTile(label: string, icon: string | null, color: string | null): MenuTile;
+declare function menuGlyph(icon: string): MenuTile;
+declare function foldText(value: string): string;
+declare function matchesRow(row: MenuRow, term: string): boolean;
+declare function selectableRows(sections: readonly MenuSection[]): MenuRow[];
+
+declare class NucleusMenu {
+    readonly sections: _angular_core.InputSignal<readonly MenuSection[]>;
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly badge: _angular_core.InputSignal<string | null>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly keyboardHint: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly select: _angular_core.OutputEmitterRef<MenuRow>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    protected readonly term: _angular_core.WritableSignal<string>;
+    private readonly searchBox;
+    private readonly root;
+    protected readonly visible: _angular_core.Signal<readonly MenuSection[]>;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    protected readonly showSearch: _angular_core.Signal<boolean>;
+    private readonly reachable;
+    private readonly activeId;
+    private readonly syncActive;
+    constructor();
+    protected isActive(row: MenuRow): boolean;
+    protected onTerm(value: string): void;
+    protected choose(row: MenuRow): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private step;
+    private scrollIntoView;
+    private focusEntry;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusMenu, "nucleus-menu", never, { "sections": { "alias": "sections"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "keyboardHint": { "alias": "keyboardHint"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "select": "select"; "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+declare class NucleusRecentApps {
+    private readonly _ids;
+    readonly ids: _angular_core.Signal<readonly string[]>;
+    remember(appId: string): void;
+    pick<T extends {
+        readonly id: string;
+    }>(source: readonly T[], limit: number): T[];
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NucleusRecentApps, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NucleusRecentApps>;
+}
+
 declare class NucleusStarfield {
     protected readonly W = 1280;
     protected readonly H = 720;
@@ -611,10 +1042,17 @@ interface ShellCopy {
     readonly navToggle: string;
     readonly appsLauncher: string;
     readonly appsEmpty: string;
+    readonly appsSwitch: string;
+    readonly appsSearch: string;
+    readonly appsNoMatch: string;
+    readonly appsRecent: string;
+    readonly appsAll: string;
+    readonly appsAvailable: string;
+    readonly appsHere: string;
+    readonly keyboardHint: string;
+    readonly accountSwitchHint: string;
+    readonly signOutHint: string;
     readonly settingsTitle: string;
-    readonly settingsTheme: string;
-    readonly settingsThemeHint: string;
-    readonly themeSystem: string;
     readonly signOut: string;
     readonly accountManage: string;
     readonly accountSwitch: string;
@@ -623,19 +1061,15 @@ interface ShellCopy {
     readonly accountScope: string;
     readonly hintComingSoon: string;
     readonly hintNotDeployed: string;
-    readonly switchSite: string;
-    readonly contextTitle: string;
-    readonly contextHint: string;
+    readonly roleCaption: string;
     readonly companyLabel: string;
     readonly companyPlaceholder: string;
     readonly siteLabel: string;
     readonly sitePlaceholder: string;
     readonly sitesLoading: string;
     readonly sitesEmpty: string;
-    readonly confirmSwitch: string;
     readonly relationOwner: string;
     readonly relationCollaborator: string;
-    readonly noContext: string;
     readonly noCompanyTitle: string;
     readonly noCompanyHint: string;
 }
@@ -646,11 +1080,6 @@ interface ShellNavItem {
     readonly icon: string;
     readonly label: string;
 }
-interface ThemeOption {
-    readonly value: ThemePreference;
-    readonly label: string;
-    readonly swatch: string | null;
-}
 interface CompanyChoice extends CompanyOption {
     readonly tag: string;
 }
@@ -663,6 +1092,7 @@ declare class NucleusShell {
     private readonly session;
     private readonly sessionAuth;
     private readonly themes;
+    private readonly recents;
     private readonly language;
     private readonly page;
     private readonly config;
@@ -685,45 +1115,60 @@ declare class NucleusShell {
         readonly user: "https://cdn.lordicon.com/hrjifpbq.json";
         readonly key: "https://cdn.lordicon.com/ossgtprr.json";
     };
+    protected readonly menuPlaceholders: string[];
     protected readonly title: _angular_core.Signal<string>;
     protected readonly subtitle: _angular_core.Signal<string>;
     protected readonly home: _angular_core.Signal<MenuItem>;
     protected readonly crumbs: _angular_core.Signal<MenuItem[]>;
     protected readonly copy: _angular_core.Signal<_nucleus_suite_pe_core.ShellCopy>;
     protected readonly starfield: _angular_core.Signal<boolean>;
-    protected readonly themePreference: _angular_core.Signal<ThemePreference>;
     protected readonly menu: _angular_core.Signal<readonly MenuNode[]>;
+    private readonly collapsedIds;
     protected readonly menuLoading: _angular_core.Signal<boolean>;
     protected readonly menuError: _angular_core.Signal<string | null>;
     protected readonly launcherApps: _angular_core.Signal<readonly _nucleus_suite_pe_core.AppSummary[]>;
     protected readonly switching: _angular_core.Signal<boolean>;
+    private readonly narrowQuery;
+    protected readonly narrow: _angular_core.WritableSignal<boolean>;
     protected readonly sidebarOpen: _angular_core.WritableSignal<boolean>;
     protected readonly settingsOpen: _angular_core.WritableSignal<boolean>;
-    protected readonly contextOpen: _angular_core.WritableSignal<boolean>;
     protected readonly companyChoice: _angular_core.WritableSignal<string | null>;
     protected readonly siteChoice: _angular_core.WritableSignal<string | null>;
     protected readonly siteOptions: _angular_core.WritableSignal<Site[]>;
     protected readonly sitesLoading: _angular_core.WritableSignal<boolean>;
     private readonly auth;
+    private sitesCompanyId;
     protected readonly identity: _angular_core.Signal<ShellIdentity | null>;
     protected readonly initials: _angular_core.Signal<string>;
     protected readonly canSwitchAccount: _angular_core.Signal<boolean>;
     protected readonly hasCompany: _angular_core.Signal<boolean>;
     protected readonly companyChoices: _angular_core.Signal<CompanyChoice[]>;
-    protected readonly contextCaption: _angular_core.Signal<string>;
     protected readonly roleName: _angular_core.Signal<string | null>;
-    protected readonly canConfirm: _angular_core.Signal<boolean>;
-    protected readonly themeOptions: _angular_core.Signal<ThemeOption[]>;
+    protected readonly words: _angular_core.Signal<_nucleus_suite_pe_core.CommonCopy>;
+    protected readonly hasSiteContext: _angular_core.Signal<boolean>;
+    protected readonly launcherRich: _angular_core.Signal<boolean>;
+    protected readonly launcherCount: _angular_core.Signal<string | null>;
+    protected readonly launcherSections: _angular_core.Signal<MenuSection[]>;
+    protected readonly accountSections: _angular_core.Signal<MenuSection[]>;
+    protected readonly accountContext: _angular_core.Signal<string>;
+    protected readonly sitePlaceholder: _angular_core.Signal<string>;
+    protected readonly topbarHeight: _angular_core.Signal<"100px" | "56px">;
+    private readonly syncContext;
     private readonly loadSession;
+    constructor();
     protected setLang(lang: NucleusLang): void;
     protected toggleSidebar(): void;
-    protected selectTheme(preference: ThemePreference | null): void;
     protected selectNav(id: string): void;
+    protected isGroup(node: MenuNode): boolean;
+    protected isExpanded(node: MenuNode): boolean;
     protected selectMenu(node: MenuNode): void;
+    private closeSidebarOnNarrow;
     protected isSelected(node: MenuNode): boolean;
-    protected openContext(): Promise<void>;
     protected onCompanyChange(companyId: string | null): Promise<void>;
-    protected confirmSwitch(): Promise<void>;
+    protected onSiteChange(siteId: string | null): Promise<void>;
+    private appRow;
+    protected onLauncherSelect(row: MenuRow): void;
+    protected onAccountSelect(row: MenuRow): void;
     protected canOpen(app: LauncherApp): boolean;
     protected launch(app: LauncherApp): void;
     protected appInitials(app: LauncherApp): string;
@@ -735,5 +1180,5 @@ declare class NucleusShell {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NucleusShell, "nucleus-shell", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "lead": { "alias": "lead"; "required": false; "isSignal": true; }; "navItems": { "alias": "navItems"; "required": false; "isSignal": true; }; "activeNavId": { "alias": "activeNavId"; "required": false; "isSignal": true; }; "selectedMenuId": { "alias": "selectedMenuId"; "required": false; "isSignal": true; }; }, { "navSelect": "navSelect"; "menuSelect": "menuSelect"; }, never, ["[nucleusTop]", "*"], true, never>;
 }
 
-export { DEFAULT_THEME, EMPTY_GEO_VALUE, GEO_COPY, NO_PERMISSIONS, NUCLEUS_CONFIG, NUCLEUS_DARK_SELECTOR, NUCLEUS_FORCE_BEARER, NUCLEUS_ICONS, NUCLEUS_LANGS, NUCLEUS_LOGOUT_PARAM, NUCLEUS_SKIP_AUTH, NucleusAuth, NucleusCard, NucleusCell, NucleusFeedback, NucleusForm, NucleusGeo, NucleusGeoSelect, NucleusLanguage, NucleusList, NucleusLordicon, NucleusMark, NucleusPage, NucleusPreset, NucleusSessionAuth, NucleusShell, NucleusStarfield, NucleusTabs, SHELL_COPY, SessionService, THEMES, THEME_LABELS, ThemeService, UserSyncService, consumeNucleusLogout, findMenuByRoute, flagOf, geoCopyOf, isNucleusConfigured, isThemePreference, levelLabel, loadLordicon, loadNucleusConfig, nucleusAuthInterceptor, nucleusLogoutUrl, ownsUrl, permissionsOf, provideNucleus, provideNucleusFeedback, provideNucleusTheme, resolveFieldSize, themeById };
-export type { AccessScope, AppSummary, AppUser, AuthSyncRequest, CardSize, CompanyOption, CompanyRelation, CompanySummary, ConfirmRequest, Crumb, FieldKind, FieldOption, FieldSize, FieldSpan, FormField, FormValue, GeoCopy, GeoCopySet, GeoCountry, GeoDivision, GeoLevel, GeoPlace, GeoValue, LauncherApp, ListAction, ListActionEvent, ListAlign, ListColumn, ListColumnKind, ListTag, ListToggleEvent, MeResponse, MenuNode, MenuPermissions, NucleusConfig, NucleusIdentity, NucleusLang, SessionTicket, ShellCopy, ShellNavItem, Site, SiteAccess, Subscription, TabItem, Theme, ThemeId, ThemePreference, ThemeTokens, UserProfile };
+export { ACCENTS, CANVASES, COMMON_COPY, CONTROL_CONTRAST, DEFAULT_APPEARANCE, DENSITIES, EMPTY_GEO_VALUE, FIELD_TARGETS, FRAMES, GEO_COPY, LEGACY_THEMES, NO_PERMISSIONS, NUCLEUS_ACCENTS, NUCLEUS_CONFIG, NUCLEUS_DARK_SELECTOR, NUCLEUS_FORCE_BEARER, NUCLEUS_ICONS, NUCLEUS_ICON_CATALOG, NUCLEUS_LANGS, NUCLEUS_LOGOUT_PARAM, NUCLEUS_SKIP_AUTH, NucleusAppearance, NucleusAuth, NucleusCache, NucleusCard, NucleusCell, NucleusColorPicker, NucleusEnterAdvance, NucleusFeedback, NucleusForm, NucleusGeo, NucleusGeoSelect, NucleusIconPicker, NucleusLanguage, NucleusList, NucleusLordicon, NucleusMark, NucleusMenu, NucleusMetric, NucleusMetrics, NucleusPage, NucleusPreset, NucleusRecentApps, NucleusSessionAuth, NucleusShell, NucleusShortcut, NucleusShortcuts, NucleusStarfield, NucleusTabs, SHELL_COPY, SessionService, TEXT_CONTRAST, THEME_COPY, ThemeService, UserSyncService, accentById, accentLabelOf, accentOn, ariaKeysOf, auditAppearance, canvasById, clock, comboOf, commonCopyOf, consumeNucleusLogout, contrastIssue, contrastRatio, day, densityById, endOfDayUtc, fieldsIn, findMenuByRoute, flagOf, foldText, frameById, geoCopyOf, hasChildren, hasModifier, iconClassOf, iconNameOf, integer, isAccentPreference, isApplePlatform, isBeforeToday, isCanvasPreference, isDarkCanvas, isDensityId, isFieldSearchable, isFrameId, isNucleusConfigured, isOnOrBeforeToday, isReachable, isToday, isTypingTarget, isoDay, levelLabel, loadLordicon, loadNucleusConfig, matchesRow, meetsContrast, menuGlyph, menuTile, minutesAsClock, mixHex, money, moveTo, normalizeKeys, nucleusAuthInterceptor, nucleusErrorMessage, nucleusLang, nucleusLogoutUrl, nucleusParseDate, ownsUrl, percent, permissionsOf, provideNucleus, provideNucleusFeedback, provideNucleusTheme, qty, readableOn, relativeLuminance, resolveAccent, resolveFieldSize, searchIcons, selectableRows, shiftDay, shortcutHint, signedMoney, stamp, startOfDayUtc, themeCopyOf, toNumber, toggleCollapsed, visibleTreeRows };
+export type { Accent, AccentId, AccentOption, AccentPreference, AccessScope, AppSummary, AppUser, Appearance, AuthSyncRequest, Canvas, CanvasEffects, CanvasId, CanvasPreference, CanvasTokens, CardSize, CommonCopy, CommonCopySet, CompanyOption, CompanyRelation, CompanySummary, ConfirmRequest, ContrastIssue, Crumb, Density, DensityId, FieldKind, FieldOption, FieldSize, FieldSpan, FormField, FormValue, Frame, FrameId, FrameTokens, GeoCopy, GeoCopySet, GeoCountry, GeoDivision, GeoLevel, GeoPlace, GeoValue, GlobalAccess, LauncherApp, ListAction, ListActionEvent, ListAlign, ListColumn, ListColumnKind, ListTag, ListToggleEvent, MeResponse, MenuNode, MenuPermissions, MenuRow, MenuSection, MenuTile, MetricTone, NucleusConfig, NucleusIdentity, NucleusLang, SessionTicket, ShellCopy, ShellNavItem, ShortcutBinding, Site, SiteAccess, Subscription, TabItem, ThemeCopy, TreeRow, UserProfile };