@ng-brutalism/ui 0.1.2 → 0.2.0

package/types/ng-brutalism-ui.d.ts

@@ -1,6 +1,7 @@
 import { ClassValue } from 'clsx';
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { InjectionToken, EnvironmentProviders, Signal } from '@angular/core';
+import * as _ng_brutalism_ui from '@ng-brutalism/ui';
 
 /**
  * Merges class names with Tailwind conflict resolution.
@@ -16,6 +17,12 @@ interface NbThemeConfig {
     primary?: string;
     secondary?: string;
     accent?: string;
+    yellow?: string;
+    pink?: string;
+    mint?: string;
+    lavender?: string;
+    blue?: string;
+    cream?: string;
     danger?: string;
     success?: string;
     warning?: string;
@@ -33,28 +40,317 @@ interface NbConfig {
 }
 declare function provideNgBrutalism(config?: NbConfig): EnvironmentProviders;
 
-type NbCheckboxSize = 'default' | 'sm' | 'lg';
+type NbTone = 'default' | 'cream' | 'white' | 'black' | 'yellow' | 'pink' | 'mint' | 'lavender' | 'blue' | 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'danger';
+interface NbToneTokens {
+    bg: string;
+    fg: string;
+}
+declare function nbToneTokens(tone: NbTone): NbToneTokens;
+/**
+ * Neutral tone aliases accepted by the tone capability in addition to the core
+ * {@link NbTone} palette. These map onto existing theme surfaces rather than
+ * the playful/semantic palette:
+ * - `surface`    → the default surface tokens
+ * - `background` → the page background/foreground
+ * - `ink`        → solid black (`black` tone)
+ */
+type NbToneToken = NbTone | 'surface' | 'background' | 'ink';
+/**
+ * Component-specific tone variables: background, foreground, and border color.
+ * Border color is always the brutalist ink (`--nb-border`) so the border
+ * *width* capability and the tone capability never fight over color.
+ */
+interface NbToneVars {
+    bg: string;
+    fg: string;
+    borderColor: string;
+}
+declare function nbToneVars(tone: NbToneToken): NbToneVars;
+
+/**
+ * Shared brutalist radius scale. One geometry per token across all primitives —
+ * the single source of truth that internal radius capabilities resolve against.
+ *
+ * Named input values are deterministic. Theme-driven radius comes from
+ * component defaults and scoped public tokens such as `--nb-button-radius`.
+ */
+type NbRadius = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+declare function nbRadiusValue(radius: NbRadius): string;
+
+/**
+ * Shared brutalist offset-shadow scale. Values are chunky, hard-edged offset
+ * shadows (no blur) tinted with `--nb-shadow`. `default` tracks the themeable
+ * `--nb-shadow-offset-x/y`.
+ */
+type NbShadow = 'none' | 'sm' | 'default' | 'hard' | 'heavy';
+declare function nbShadowValue(shadow: NbShadow): string;
+
+/**
+ * Shared border-strength scale. Resolves to a border *width* only — border
+ * *color* is owned by the tone vocabulary (`nbToneVars().borderColor`) so the
+ * two never fight. `default` tracks the themeable `--nb-border-width`.
+ */
+type NbBorderStrength = 'none' | 'thin' | 'default' | 'strong' | 'thick';
+declare function nbBorderWidthValue(border: NbBorderStrength): string;
+
+/**
+ * Shared spacing scale used for layout `gap` across nbStack / nbCluster /
+ * nbSplit. One source of truth so a given gap token means the same distance
+ * everywhere.
+ */
+type NbSpacing = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+declare function nbSpacingValue(spacing: NbSpacing): string;
+
+/**
+ * Shared container-padding scale (uniform). Used by layout/container primitives
+ * that own symmetric padding (nbSection / nbCluster / nbSplit). Pill-style
+ * primitives (nbChip) and asymmetric surfaces keep their own padding because
+ * their spacing is anatomy, not a uniform container token.
+ */
+type NbPadding = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare function nbPaddingValue(padding: NbPadding): string;
+
+/**
+ * Divider line placement between layout regions. Distinct from `border`
+ * (outline strength): `divider` describes *which side(s)* carry a separating
+ * line, while `border` describes *how thick* an element's outline is.
+ */
+type NbDivider = 'none' | 'top' | 'right' | 'bottom' | 'left' | 'block' | 'inline' | 'all';
+
+/**
+ * Shared typography vocabulary. One source of truth for the font-weight scale,
+ * the font-role contract, underline customization, and the text-tracking scale
+ * so a token means the same thing across nbText / nbDisplay / nbTypography /
+ * nbChipGroup.
+ */
+/**
+ * Shared underline variant used by both nbText and nbDisplay.
+ * `NbTextUnderline` and `NbDisplayUnderline` are public aliases of this type.
+ */
+type NbUnderlineVariant = 'none' | 'bar' | 'wave';
+/**
+ * Letter-spacing scale shared by nbText and nbChipGroup.
+ * Exported publicly as `NbTextTracking` from the text barrel.
+ */
+type NbTextTracking = 'tight' | 'normal' | 'wide' | 'wider';
+/** Font-weight scale shared by nbText and nbDisplay. */
+type NbFontWeight = 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
+declare function nbFontWeightValue(weight: NbFontWeight): string;
+/**
+ * Font-role contract. The API picks a *role*; the role maps to a CSS token that
+ * defines the actual stack, so theming/customization stays in CSS and templates
+ * keep type safety. Each role falls back to the sans stack when its token is
+ * unset. `inherit` writes nothing so the element keeps its inherited font.
+ */
+type NbTypographyFont = 'inherit' | 'body' | 'display' | 'accent' | 'mono';
+declare function nbTypographyFontValue(font: NbTypographyFont): string | null;
+/**
+ * Underline customization shared by nbText / nbDisplay `underline="bar"|"wave"`.
+ * Writes the public `--nb-underline-gap` / `--nb-underline-width` tokens that the
+ * underline CSS already reads. `auto` leaves the CSS default in place. Color and
+ * thickness remain token-driven (`--nb-underline-color`, `--nb-underline-height`)
+ * for the rarer brand-specific cases.
+ */
+type NbUnderlineGap = 'none' | 'xs' | 'sm' | 'md' | 'lg';
+type NbUnderlineWidth = 'auto' | 'xs' | 'sm' | 'md' | 'lg' | 'full';
+declare function nbUnderlineGapValue(gap: NbUnderlineGap): string;
+declare function nbUnderlineWidthValue(width: NbUnderlineWidth): string | null;
+
+/**
+ * INTERNAL. The CSS-variable namespace a primitive owns, e.g. `'surface'` →
+ * capabilities write `--nb-surface-*`. Every primitive that composes a style
+ * capability must provide this on its element injector.
+ */
+declare const NB_STYLE_NAMESPACE: InjectionToken<string>;
+/**
+ * INTERNAL. Per-primitive default tokens. A capability resolves its value as:
+ * explicit input → this default → the capability's own hard fallback.
+ */
+interface NbStyleDefaults {
+    tone?: NbToneToken;
+    radius?: NbRadius;
+    shadow?: NbShadow;
+    border?: NbBorderStrength;
+    padding?: NbPadding;
+    gap?: NbSpacing;
+}
+declare const NB_STYLE_DEFAULTS: InjectionToken<NbStyleDefaults>;
+
+/**
+ * INTERNAL capability — not part of the public API. Composed into primitives via
+ * `hostDirectives`. Defaults and scoped public tokens flow through low
+ * specificity marker CSS; explicit inputs write final inline color properties.
+ */
+declare class NbToneCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly tone: _angular_core.InputSignal<NbToneToken | undefined>;
+    protected readonly resolved: _angular_core.Signal<NbToneToken>;
+    private readonly defaultVars;
+    private readonly inputVars;
+    protected readonly toneBgDefaultVar: _angular_core.Signal<string>;
+    protected readonly toneFgDefaultVar: _angular_core.Signal<string>;
+    protected readonly toneBorderColorDefaultVar: _angular_core.Signal<string>;
+    protected readonly toneBgTokenVar: _angular_core.Signal<string>;
+    protected readonly toneFgTokenVar: _angular_core.Signal<string>;
+    protected readonly toneBorderColorTokenVar: _angular_core.Signal<string>;
+    protected readonly toneInputBgStyle: _angular_core.Signal<string | null>;
+    protected readonly toneInputFgStyle: _angular_core.Signal<string | null>;
+    protected readonly toneInputBorderColorStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbToneCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbToneCapability, "[nbToneCapability]", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Defaults and scoped public
+ * tokens flow through marker CSS; explicit inputs write the final property.
+ */
+declare class NbRadiusCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly radius: _angular_core.InputSignal<NbRadius | undefined>;
+    private readonly fallback;
+    protected readonly resolved: _angular_core.Signal<NbRadius>;
+    protected readonly radiusDefaultVar: _angular_core.Signal<string>;
+    protected readonly radiusTokenVar: _angular_core.Signal<string>;
+    protected readonly radiusInputStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbRadiusCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbRadiusCapability, "[nbRadiusCapability]", never, { "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Defaults and scoped public
+ * tokens flow through marker CSS; explicit inputs write the final property.
+ */
+declare class NbShadowCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly shadow: _angular_core.InputSignal<NbShadow | undefined>;
+    private readonly fallback;
+    protected readonly resolved: _angular_core.Signal<NbShadow>;
+    protected readonly shadowDefaultVar: _angular_core.Signal<string>;
+    protected readonly shadowTokenVar: _angular_core.Signal<string>;
+    protected readonly shadowInputStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbShadowCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbShadowCapability, "[nbShadowCapability]", never, { "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Defaults and scoped public
+ * tokens flow through marker CSS; explicit inputs write the final property.
+ * Border color is owned by the tone capability.
+ */
+declare class NbBorderCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly border: _angular_core.InputSignal<NbBorderStrength | undefined>;
+    private readonly fallback;
+    protected readonly resolved: _angular_core.Signal<NbBorderStrength>;
+    protected readonly borderWidthDefaultVar: _angular_core.Signal<string>;
+    protected readonly borderWidthTokenVar: _angular_core.Signal<string>;
+    protected readonly borderWidthInputStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbBorderCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbBorderCapability, "[nbBorderCapability]", never, { "border": { "alias": "border"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Defaults and scoped public
+ * tokens flow through marker CSS; explicit inputs write the final property.
+ */
+declare class NbPaddingCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly padding: _angular_core.InputSignal<NbPadding | undefined>;
+    private readonly fallback;
+    protected readonly resolved: _angular_core.Signal<NbPadding>;
+    protected readonly paddingDefaultVar: _angular_core.Signal<string>;
+    protected readonly paddingTokenVar: _angular_core.Signal<string>;
+    protected readonly paddingInputStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbPaddingCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbPaddingCapability, "[nbPaddingCapability]", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Defaults and scoped public
+ * tokens flow through marker CSS; explicit inputs write the final property.
+ */
+declare class NbGapCapability {
+    private readonly namespace;
+    private readonly defaults;
+    readonly gap: _angular_core.InputSignal<NbSpacing | undefined>;
+    private readonly fallback;
+    protected readonly resolved: _angular_core.Signal<NbSpacing>;
+    protected readonly gapDefaultVar: _angular_core.Signal<string>;
+    protected readonly gapInputVar: _angular_core.Signal<string | null>;
+    protected readonly gapResolvedVar: _angular_core.Signal<string>;
+    protected readonly gapInputStyle: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbGapCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbGapCapability, "[nbGapCapability]", never, { "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Handles the three underline
+ * inputs shared by nbText and nbDisplay: the variant (none/bar/wave), the gap
+ * between text baseline and the decoration, and the decoration width.
+ *
+ * Writes `data-underline`, `--nb-underline-gap`, and `--nb-underline-width`
+ * onto the host when the Angular inputs are present so the underline CSS in the
+ * theme can read them without each text primitive re-implementing the same
+ * computed chain.
+ */
+declare class NbUnderlineCapability {
+    private readonly element;
+    private readonly writtenCustomProperties;
+    readonly underline: _angular_core.InputSignal<NbUnderlineVariant>;
+    readonly underlineGap: _angular_core.InputSignal<NbUnderlineGap | undefined>;
+    readonly underlineWidth: _angular_core.InputSignal<NbUnderlineWidth | undefined>;
+    constructor();
+    protected readonly underlineAttr: _angular_core.Signal<"bar" | "wave" | null>;
+    protected readonly underlineGapValue: _angular_core.Signal<string | null>;
+    protected readonly underlineWidthValue: _angular_core.Signal<string | null>;
+    private syncCustomProperty;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbUnderlineCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbUnderlineCapability, "[nbUnderlineCapability]", never, { "underline": { "alias": "underline"; "required": false; "isSignal": true; }; "underlineGap": { "alias": "underlineGap"; "required": false; "isSignal": true; }; "underlineWidth": { "alias": "underlineWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * INTERNAL capability — not part of the public API. Marks the host for a
+ * low-specificity stylesheet margin reset when `reset` is true (the default),
+ * so browser-default margins on `<p>`, `<h1>`–`<h6>`, and other typographic
+ * elements don't interfere with layout-primitive spacing (nbStack, nbCluster,
+ * etc.).
+ *
+ * Shared by nbText and nbDisplay so neither primitive re-implements the same
+ * one-line computed.
+ */
+declare class NbResetMarginCapability {
+    readonly reset: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbResetMarginCapability, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbResetMarginCapability, "[nbResetMarginCapability]", never, { "reset": { "alias": "reset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NbCheckboxSize = 'md' | 'sm' | 'lg';
 
 declare class NbCheckbox {
-    readonly size: i0.InputSignal<NbCheckboxSize>;
-    protected readonly classes: i0.Signal<string>;
+    readonly size: _angular_core.InputSignal<NbCheckboxSize>;
+    protected readonly classes: _angular_core.Signal<string>;
     private sizeClass;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCheckbox, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbCheckbox, "input[nbCheckbox]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCheckbox, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbCheckbox, "input[nbCheckbox]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class NbAccordionItem {
     private readonly id;
-    readonly value: i0.InputSignal<string>;
-    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private readonly accordion;
     readonly triggerId: string;
     readonly contentId: string;
-    readonly open: i0.Signal<boolean>;
-    protected readonly classes: i0.Signal<string>;
+    readonly open: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
     toggle(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordionItem, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbAccordionItem, "nb-accordion-item", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAccordionItem, "nb-accordion-item", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
 }
 
 type NbAccordionType = 'single' | 'multiple';
@@ -65,159 +361,271 @@ interface NbAccordionController {
 }
 
 declare class NbAccordion implements NbAccordionController {
-    readonly type: i0.InputSignal<NbAccordionType>;
-    readonly collapsible: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly value: i0.ModelSignal<NbAccordionValue>;
-    readonly items: i0.Signal<readonly NbAccordionItem[]>;
+    readonly type: _angular_core.InputSignal<NbAccordionType>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.ModelSignal<NbAccordionValue>;
+    readonly items: _angular_core.Signal<readonly NbAccordionItem[]>;
     isItemOpen(value: string): boolean;
     toggleItem(value: string): void;
     private toggleMultipleItem;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordion, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbAccordion, "nb-accordion", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["items"], ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAccordion, "nb-accordion", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["items"], ["*"], true, never>;
 }
 
 declare class NbAccordionContent {
     protected readonly item: NbAccordionItem;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordionContent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbAccordionContent, "nb-accordion-content", never, {}, {}, never, ["*"], true, never>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAccordionContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAccordionContent, "nb-accordion-content", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class NbAccordionTrigger {
     protected readonly item: NbAccordionItem;
-    protected readonly triggerClasses: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordionTrigger, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbAccordionTrigger, "nb-accordion-trigger", never, {}, {}, never, ["*"], true, never>;
+    protected readonly triggerClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAccordionTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAccordionTrigger, "nb-accordion-trigger", never, {}, {}, never, ["*"], true, never>;
 }
 
-type NbButtonVariant = 'default' | 'neutral' | 'primary' | 'secondary' | 'accent' | 'danger' | 'success' | 'warning';
-type NbButtonShadow = 'default' | 'none' | 'reverse';
-type NbButtonSize = 'default' | 'sm' | 'lg' | 'icon';
+type NbButtonTone = NbToneToken;
+type NbButtonShadow = NbShadow;
+type NbButtonPress = 'push' | 'reverse' | 'none';
+type NbButtonSize = 'sm' | 'md' | 'lg' | 'xl';
+type NbButtonRadius = NbRadius;
+type NbButtonIconSize = 'sm' | 'md' | 'lg';
+type NbButtonIconShape = 'none' | 'square' | 'circle';
+type NbButtonIconTone = 'default' | 'inverse' | 'current';
+type NbButtonIconPush = 'none' | 'end';
 
 declare class NbButton {
-    readonly variant: i0.InputSignal<NbButtonVariant>;
-    readonly shadow: i0.InputSignal<NbButtonShadow>;
-    readonly size: i0.InputSignal<NbButtonSize>;
-    readonly fullWidth: i0.InputSignal<boolean>;
-    protected readonly classes: i0.Signal<string>;
-    private variantClass;
+    readonly press: _angular_core.InputSignal<NbButtonPress>;
+    readonly size: _angular_core.InputSignal<NbButtonSize>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly classes: _angular_core.Signal<string>;
     private shadowClass;
     private sizeClass;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbButton, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbButton, "button[nbButton], a[nbButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbButton, "button[nbButton], a[nbButton]", never, { "press": { "alias": "press"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
+}
+
+type NbIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type NbIconTone = 'current' | 'default' | 'muted' | 'inverse' | 'primary' | 'secondary' | 'accent' | 'danger' | 'success' | 'warning';
+type NbIconMode = 'mask' | 'image';
+declare class NbIcon {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly mode: _angular_core.InputSignal<NbIconMode>;
+    readonly size: _angular_core.InputSignal<NbIconSize>;
+    readonly tone: _angular_core.InputSignal<NbIconTone>;
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    private hasWarnedAboutMissingA11y;
+    protected readonly sizeValue: _angular_core.Signal<string>;
+    protected readonly toneValue: _angular_core.Signal<string>;
+    protected readonly srcValue: _angular_core.Signal<string>;
+    protected readonly isMaskMode: _angular_core.Signal<boolean>;
+    protected readonly isImageMode: _angular_core.Signal<boolean>;
+    protected readonly roleValue: _angular_core.Signal<"img" | null>;
+    protected readonly ariaHiddenValue: _angular_core.Signal<"true" | null>;
+    protected readonly ariaLabelValue: _angular_core.Signal<string | null>;
+    protected readonly backgroundColorValue: _angular_core.Signal<"var(--nb-icon-color, currentColor)" | null>;
+    protected readonly backgroundImageValue: _angular_core.Signal<string | null>;
+    protected readonly backgroundSizeValue: _angular_core.Signal<"contain" | null>;
+    protected readonly backgroundPositionValue: _angular_core.Signal<"center" | null>;
+    protected readonly backgroundRepeatValue: _angular_core.Signal<"no-repeat" | null>;
+    protected readonly maskImageValue: _angular_core.Signal<string | null>;
+    protected readonly maskSizeValue: _angular_core.Signal<"contain" | null>;
+    protected readonly maskPositionValue: _angular_core.Signal<"center" | null>;
+    protected readonly maskRepeatValue: _angular_core.Signal<"no-repeat" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbIcon, "[nbIcon]", ["nbIcon"], { "src": { "alias": "src"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NbButtonTrailingIcon {
+    readonly size: _angular_core.InputSignal<NbButtonIconSize | undefined>;
+    readonly shape: _angular_core.InputSignal<NbButtonIconShape | undefined>;
+    readonly tone: _angular_core.InputSignal<NbButtonIconTone | undefined>;
+    readonly push: _angular_core.InputSignal<NbButtonIconPush>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    protected readonly sizeVal: _angular_core.Signal<string | null>;
+    protected readonly iconSize: _angular_core.Signal<NbIconSize>;
+    protected readonly radiusVal: _angular_core.Signal<string | null>;
+    protected readonly bgVal: _angular_core.Signal<string | null>;
+    protected readonly colorVal: _angular_core.Signal<string | null>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbButtonTrailingIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbButtonTrailingIcon, "[nbButtonTrailingIcon]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "push": { "alias": "push"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 type NbCardActionsAlign = 'start' | 'end';
+type NbCardTone = NbToneToken;
+type NbCardRadius = NbRadius;
+type NbCardShadow = NbShadow;
+type NbCardBorder = NbBorderStrength;
 declare class NbCard {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCard, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCard, "nb-card", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCard, "nb-card", never, {}, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
 }
 declare class NbCardHeader {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardHeader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardHeader, "nb-card-header", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardHeader, "nb-card-header", never, {}, {}, never, ["*"], true, never>;
 }
 declare class NbCardTitle {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardTitle, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardTitle, "nb-card-title", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardTitle, "nb-card-title", never, {}, {}, never, ["*"], true, never>;
 }
 declare class NbCardDescription {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardDescription, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardDescription, "nb-card-description", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardDescription, "nb-card-description", never, {}, {}, never, ["*"], true, never>;
 }
 declare class NbCardActions {
-    readonly align: i0.InputSignal<NbCardActionsAlign>;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardActions, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardActions, "nb-card-actions", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    readonly align: _angular_core.InputSignal<NbCardActionsAlign>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardActions, "nb-card-actions", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 declare class NbCardContent {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardContent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardContent, "nb-card-content", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardContent, "nb-card-content", never, {}, {}, never, ["*"], true, never>;
 }
 declare class NbCardFooter {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbCardFooter, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbCardFooter, "nb-card-footer", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbCardFooter, "nb-card-footer", never, {}, {}, never, ["*"], true, never>;
 }
 
+type NbImageCardTone = NbToneToken;
+type NbImageCardRadius = NbRadius;
+type NbImageCardShadow = NbShadow;
+type NbImageCardBorder = NbBorderStrength;
 declare class NbImageCard {
-    readonly image: i0.InputSignal<string>;
-    readonly alt: i0.InputSignal<string>;
+    readonly image: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
     protected readonly classes: string;
     protected readonly imageClasses: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbImageCard, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbImageCard, "nb-image-card", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "alt": { "alias": "alt"; "required": true; "isSignal": true; }; }, {}, never, ["nb-image-card-caption"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbImageCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbImageCard, "nb-image-card", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "alt": { "alias": "alt"; "required": true; "isSignal": true; }; }, {}, never, ["nb-image-card-caption"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
 }
 declare class NbImageCardCaption {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbImageCardCaption, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbImageCardCaption, "nb-image-card-caption", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbImageCardCaption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbImageCardCaption, "nb-image-card-caption", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class NbMarquee {
-    readonly duration: i0.InputSignal<string>;
-    readonly reverse: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly pauseOnHover: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly duration: _angular_core.InputSignal<string>;
+    readonly reverse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pauseOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private readonly wrapper;
     private readonly strip1;
     private readonly strip2;
     private readonly destroyRef;
     private readonly isBrowser;
     private readonly widthScale;
-    protected readonly wrapperClass: i0.Signal<string>;
-    protected readonly wrapperStyle: i0.Signal<{
+    protected readonly wrapperClass: _angular_core.Signal<string>;
+    protected readonly wrapperStyle: _angular_core.Signal<{
         '--nb-marquee-duration': string;
     }>;
     private readonly scaledDuration;
-    protected readonly strip1Class: i0.Signal<string>;
-    protected readonly strip2Class: i0.Signal<string>;
+    protected readonly strip1Class: _angular_core.Signal<string>;
+    protected readonly strip2Class: _angular_core.Signal<string>;
     constructor();
     private syncSecondStrip;
     private updateAnimationScale;
     private durationToMs;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbMarquee, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbMarquee, "nb-marquee", never, { "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMarquee, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbMarquee, "nb-marquee", never, { "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class NbMarqueeItem {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbMarqueeItem, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbMarqueeItem, "nb-marquee-item", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMarqueeItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbMarqueeItem, "nb-marquee-item", never, {}, {}, never, ["*"], true, never>;
 }
 
-type NbInputSize = 'default' | 'sm' | 'lg';
+type NbInputSize = 'md' | 'sm' | 'lg';
 
 declare class NbInput {
-    readonly size: i0.InputSignal<NbInputSize>;
+    readonly size: _angular_core.InputSignal<NbInputSize>;
     private readonly group;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbInput, "input[nbInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbInput, "input[nbInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class NbLabel {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbLabel, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbLabel, "label[nbLabel]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbLabel, "label[nbLabel]", never, {}, {}, never, never, true, never>;
 }
 
 declare class NbTitle {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbTitle, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbTitle, "[nbTitle]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbTitle, "[nbTitle]", never, {}, {}, never, never, true, never>;
+}
+
+type NbDisplaySize = 'sm' | 'md' | 'lg' | 'xl';
+type NbDisplayWeight = NbFontWeight;
+type NbDisplayTracking = 'normal' | 'tight' | 'tighter';
+type NbDisplayLeading = 'none' | 'tight' | 'display';
+type NbDisplayUnderline = NbUnderlineVariant;
+declare class NbDisplay {
+    readonly size: _angular_core.InputSignal<NbDisplaySize>;
+    readonly weight: _angular_core.InputSignal<NbFontWeight>;
+    readonly fluid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tracking: _angular_core.InputSignal<NbDisplayTracking>;
+    readonly leading: _angular_core.InputSignal<NbDisplayLeading>;
+    protected readonly fontSize: _angular_core.Signal<string>;
+    protected readonly weightValue: _angular_core.Signal<string>;
+    protected readonly trackingValue: _angular_core.Signal<string>;
+    protected readonly leadingValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDisplay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbDisplay, "[nbDisplay]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "tracking": { "alias": "tracking"; "required": false; "isSignal": true; }; "leading": { "alias": "leading"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbUnderlineCapability; inputs: { "underline": "underline"; "underlineGap": "underlineGap"; "underlineWidth": "underlineWidth"; }; outputs: {}; }, { directive: typeof NbResetMarginCapability; inputs: { "reset": "reset"; }; outputs: {}; }]>;
+}
+
+/**
+ * Typography context. Picks a font *role* and writes the resolved stack as
+ * `font-family` on the host so every descendant primitive (nbText, nbDisplay,
+ * nbButton, nbChip, nbMediaItemTitle, …) inherits it through the cascade — no
+ * raw font-family strings in templates.
+ *
+ * Precedence falls out of the cascade: a nested context overrides an outer one
+ * (closest wins), and an inline token override (`--nb-font-accent: …`) wins over
+ * the preset because the resolved value reads that token first.
+ *
+ * Also available as the `typography` input on nbSurface, which composes this
+ * directive directly.
+ */
+declare class NbTypography {
+    readonly font: _angular_core.InputSignal<NbTypographyFont>;
+    protected readonly fontValue: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbTypography, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbTypography, "[nbTypography]", ["nbTypography"], { "font": { "alias": "font"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NbSeparatorOrientation = 'horizontal' | 'vertical';
+type NbSeparatorVariant = 'solid' | 'dashed' | 'thick';
+declare class NbSeparator {
+    readonly orientation: _angular_core.InputSignal<NbSeparatorOrientation>;
+    readonly variant: _angular_core.InputSignal<NbSeparatorVariant>;
+    protected readonly isHorizontal: _angular_core.Signal<boolean>;
+    protected readonly isVertical: _angular_core.Signal<boolean>;
+    protected readonly borderLine: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbSeparator, "hr[nbSeparator]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type NbTextareaSize = 'default' | 'sm' | 'lg';
+type NbTextareaSize = 'md' | 'sm' | 'lg';
 
 declare class NbTextarea {
-    readonly size: i0.InputSignal<NbTextareaSize>;
+    readonly size: _angular_core.InputSignal<NbTextareaSize>;
     private readonly group;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbTextarea, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbTextarea, "textarea[nbTextarea]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbTextarea, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbTextarea, "textarea[nbTextarea]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface NbInputGroupContext {
@@ -228,34 +636,34 @@ interface NbInputGroupContext {
 declare class NbInputGroup implements NbInputGroupContext {
     private readonly prefixes;
     private readonly suffixes;
-    readonly hasPrefix: i0.Signal<boolean>;
-    readonly hasSuffix: i0.Signal<boolean>;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbInputGroup, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbInputGroup, "nb-input-group", never, {}, {}, ["prefixes", "suffixes"], ["*"], true, never>;
+    readonly hasPrefix: _angular_core.Signal<boolean>;
+    readonly hasSuffix: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbInputGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbInputGroup, "nb-input-group", never, {}, {}, ["prefixes", "suffixes"], ["*"], true, never>;
 }
 
 type NbInputPrefixAlign = 'center' | 'stretch';
 declare class NbInputPrefix {
-    readonly align: i0.InputSignal<NbInputPrefixAlign>;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbInputPrefix, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbInputPrefix, "[nbInputPrefix]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly align: _angular_core.InputSignal<NbInputPrefixAlign>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbInputPrefix, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbInputPrefix, "[nbInputPrefix]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type NbInputSuffixAlign = 'center' | 'stretch';
 declare class NbInputSuffix {
-    readonly align: i0.InputSignal<NbInputSuffixAlign>;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbInputSuffix, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbInputSuffix, "[nbInputSuffix]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly align: _angular_core.InputSignal<NbInputSuffixAlign>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbInputSuffix, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbInputSuffix, "[nbInputSuffix]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class NbNativeSelect {
     private readonly group;
-    protected readonly classes: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbNativeSelect, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbNativeSelect, "select[nbSelect]", never, {}, {}, never, never, true, never>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbNativeSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbNativeSelect, "select[nbSelect]", never, {}, {}, never, never, true, never>;
 }
 
 type NbSelectValue = string | number;
@@ -273,37 +681,37 @@ declare class NbSelectOption {
     private readonly element;
     protected readonly select: NbSelectController;
     readonly id: string;
-    readonly value: i0.InputSignal<NbSelectValue | null>;
-    readonly label: i0.InputSignal<string>;
-    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
-    protected readonly selected: i0.Signal<boolean>;
-    protected readonly showIndicator: i0.Signal<boolean>;
-    protected readonly classes: i0.Signal<string>;
+    readonly value: _angular_core.InputSignal<NbSelectValue | null>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly showIndicator: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
     focus(): void;
     selectOptionOnKey(event: KeyboardEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbSelectOption, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbSelectOption, "nb-select-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSelectOption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbSelectOption, "nb-select-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class NbSelect implements NbSelectController {
     private readonly element;
     private readonly group;
-    readonly placeholder: i0.InputSignal<string>;
-    readonly value: i0.ModelSignal<NbSelectValue | null>;
-    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly ariaLabel: i0.InputSignal<string | null>;
-    readonly ariaLabelledby: i0.InputSignal<string | null>;
-    readonly options: i0.Signal<readonly NbSelectOption[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.ModelSignal<NbSelectValue | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly options: _angular_core.Signal<readonly NbSelectOption[]>;
     private readonly trigger;
-    readonly open: i0.ModelSignal<boolean>;
+    readonly open: _angular_core.ModelSignal<boolean>;
     readonly id: number;
     readonly triggerId: string;
     readonly listboxId: string;
-    protected readonly selectedOption: i0.Signal<NbSelectOption | undefined>;
-    protected readonly selectedLabel: i0.Signal<string>;
-    protected readonly hostClasses: i0.Signal<string>;
-    protected readonly triggerClasses: i0.Signal<string>;
-    protected readonly valueClasses: i0.Signal<string>;
+    protected readonly selectedOption: _angular_core.Signal<NbSelectOption | undefined>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly triggerClasses: _angular_core.Signal<string>;
+    protected readonly valueClasses: _angular_core.Signal<string>;
     protected readonly listboxClasses: string;
     isSelected(value: NbSelectValue | null): boolean;
     selectOption(option: NbSelectOption): void;
@@ -316,26 +724,69 @@ declare class NbSelect implements NbSelectController {
     closeOnOutsideClick(event: MouseEvent): void;
     private firstEnabledOption;
     private focusRelativeOption;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbSelect, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbSelect, "nb-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; }, ["options"], ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbSelect, "nb-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; }, ["options"], ["*"], true, never>;
 }
 
-type NbBadgeVariant = 'default' | 'secondary' | 'success' | 'warning' | 'danger';
-
+type NbBadgeTone = NbToneToken;
+type NbBadgeRadius = NbRadius;
+type NbBadgeShadow = NbShadow;
+type NbBadgeBorder = NbBorderStrength;
 declare class NbBadge {
-    readonly variant: i0.InputSignal<NbBadgeVariant>;
-    protected readonly classes: i0.Signal<string>;
-    private variantClass;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbBadge, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbBadge, "span[nbBadge]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected readonly classes: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbBadge, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbBadge, "span[nbBadge]", never, {}, {}, never, never, true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
 }
 
+type NbAvatarTone = NbToneToken;
+type NbAvatarRadius = NbRadius;
+type NbAvatarShadow = NbShadow;
+type NbAvatarBorder = NbBorderStrength;
 declare class NbAvatar {
-    readonly src: i0.InputSignal<string | undefined>;
-    readonly alt: i0.InputSignal<string>;
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly alt: _angular_core.InputSignal<string>;
+    protected readonly classes: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAvatar, "nb-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
+}
+
+type NbMediaFrameTone = NbToneToken;
+type NbMediaFrameRadius = NbRadius;
+type NbMediaFrameShadow = NbShadow;
+type NbMediaFrameBorder = NbBorderStrength;
+type NbMediaFrameRatio = 'auto' | '1/1' | '3/4' | '4/3' | '3/2' | '16/9' | '21/9';
+type NbMediaFrameFit = 'cover' | 'contain' | 'fill';
+declare class NbMediaFrame {
+    readonly ratio: _angular_core.InputSignal<NbMediaFrameRatio>;
+    readonly fit: _angular_core.InputSignal<NbMediaFrameFit>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private ratioClass;
+    private fitClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMediaFrame, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbMediaFrame, "[nbMediaFrame]", never, { "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
+}
+
+declare class NbStat {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly direction: _angular_core.InputSignal<"row" | "column">;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbStat, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbStat, "nb-stat", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=icon]"], true, never>;
+}
+
+declare class NbRating {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly count: _angular_core.InputSignal<number | undefined>;
+    protected readonly stars: _angular_core.Signal<number[]>;
+    protected readonly filled: _angular_core.Signal<number>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbAvatar, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbAvatar, "nb-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    protected readonly filledClass: string;
+    protected readonly emptyClass: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbRating, "nb-rating", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface NbDialogController {
@@ -350,38 +801,361 @@ declare class NbDialog implements NbDialogController {
     open(): void;
     close(): void;
     protected dismissOnBackdrop(event: MouseEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialog, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbDialog, "nb-dialog", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbDialog, "nb-dialog", never, {}, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
 }
 
 declare class NbDialogTitle {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogTitle, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbDialogTitle, "[nbDialogTitle]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialogTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbDialogTitle, "[nbDialogTitle]", never, {}, {}, never, never, true, never>;
 }
 
 declare class NbDialogDescription {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogDescription, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbDialogDescription, "[nbDialogDescription]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialogDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbDialogDescription, "[nbDialogDescription]", never, {}, {}, never, never, true, never>;
 }
 
 declare class NbDialogContent {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogContent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbDialogContent, "nb-dialog-content", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialogContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbDialogContent, "nb-dialog-content", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class NbDialogActions {
     protected readonly classes: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogActions, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NbDialogActions, "nb-dialog-actions", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialogActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbDialogActions, "nb-dialog-actions", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class NbDialogClose {
     protected readonly controller: NbDialogController;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogClose, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NbDialogClose, "[nbDialogClose]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbDialogClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbDialogClose, "[nbDialogClose]", never, {}, {}, never, never, true, never>;
+}
+
+type NbStatusDotState = 'online' | 'offline' | 'live';
+type NbStatusDotSize = 'xs' | 'sm' | 'md' | 'lg';
+declare class NbStatusDot {
+    readonly state: _angular_core.InputSignal<NbStatusDotState>;
+    readonly size: _angular_core.InputSignal<NbStatusDotSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    protected readonly sizeVar: _angular_core.Signal<string>;
+    private stateClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbStatusDot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbStatusDot, "span[nbStatusDot]", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }]>;
+}
+
+type NbTextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+type NbTextWeight = NbFontWeight;
+type NbTextTone = 'default' | 'muted' | 'subtle' | 'inverse' | Extract<NbTone, 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'danger'>;
+type NbTextTransform = 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+
+type NbTextMeasure = 'none' | 'xs' | 'sm' | 'md' | 'lg';
+type NbTextLeading = 'none' | 'tight' | 'normal' | 'relaxed';
+declare class NbText {
+    readonly size: _angular_core.InputSignal<NbTextSize>;
+    readonly weight: _angular_core.InputSignal<NbFontWeight>;
+    readonly tone: _angular_core.InputSignal<NbTextTone>;
+    readonly transform: _angular_core.InputSignal<NbTextTransform>;
+    readonly tracking: _angular_core.InputSignal<NbTextTracking>;
+    readonly measure: _angular_core.InputSignal<NbTextMeasure>;
+    readonly leading: _angular_core.InputSignal<NbTextLeading>;
+    protected readonly sizeValue: _angular_core.Signal<string>;
+    protected readonly lineHeightValue: _angular_core.Signal<string>;
+    protected readonly weightValue: _angular_core.Signal<string>;
+    protected readonly colorValue: _angular_core.Signal<string>;
+    protected readonly transformValue: _angular_core.Signal<NbTextTransform>;
+    protected readonly trackingValue: _angular_core.Signal<string>;
+    protected readonly measureValue: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbText, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbText, "[nbText]", ["nbText"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "tracking": { "alias": "tracking"; "required": false; "isSignal": true; }; "measure": { "alias": "measure"; "required": false; "isSignal": true; }; "leading": { "alias": "leading"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbUnderlineCapability; inputs: { "underline": "underline"; "underlineGap": "underlineGap"; "underlineWidth": "underlineWidth"; }; outputs: {}; }, { directive: typeof NbResetMarginCapability; inputs: { "reset": "reset"; }; outputs: {}; }]>;
+}
+
+type NbChipTone = NbToneToken;
+type NbChipPadding = 'none' | 'sm' | 'md' | 'lg' | 'xl';
+declare class NbChip {
+    readonly padding: _angular_core.InputSignal<NbChipPadding>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly iconSize: _angular_core.InputSignal<NbIconSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbChip, "span[nbChip]", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
+}
+type NbChipGroupDirection = 'horizontal' | 'vertical';
+type NbChipGroupAlign = 'start' | 'center' | 'end' | 'stretch';
+/**
+ * Layout + shared style context for a set of chips. Owns the row/column layout
+ * (direction, gap, align) and broadcasts chip-level styling — radius, shadow,
+ * text transform, tracking — to every child `nbChip` through CSS variables and
+ * inherited text properties, so chips don't repeat the same inputs. Individual
+ * `nbChip` inputs still override the group (explicit input beats context token).
+ */
+declare class NbChipGroup {
+    readonly direction: _angular_core.InputSignal<NbChipGroupDirection>;
+    readonly gap: _angular_core.InputSignal<NbSpacing>;
+    readonly align: _angular_core.InputSignal<NbChipGroupAlign>;
+    readonly radius: _angular_core.InputSignal<NbRadius | undefined>;
+    readonly shadow: _angular_core.InputSignal<NbShadow | undefined>;
+    readonly transform: _angular_core.InputSignal<NbTextTransform>;
+    readonly tracking: _angular_core.InputSignal<NbTextTracking>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly gapValue: _angular_core.Signal<string>;
+    protected readonly chipRadiusValue: _angular_core.Signal<string | null>;
+    protected readonly chipShadowValue: _angular_core.Signal<string | null>;
+    protected readonly transformValue: _angular_core.Signal<"uppercase" | "lowercase" | "capitalize" | null>;
+    protected readonly trackingValue: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbChipGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbChipGroup, "[nbChipGroup]", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "tracking": { "alias": "tracking"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NbIconButtonShape = 'square' | 'circle';
+type NbIconButtonSize = 'sm' | 'md' | 'lg' | 'xl';
+declare class NbIconButton {
+    readonly shape: _angular_core.InputSignal<NbIconButtonShape>;
+    readonly size: _angular_core.InputSignal<NbIconButtonSize>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    protected readonly iconSize: _angular_core.Signal<NbIconSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbIconButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbIconButton, "button[nbIconButton]", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }]>;
+}
+
+type NbProgressTone = 'default' | 'success' | 'warning' | 'danger' | 'accent';
+declare class NbProgress {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly tone: _angular_core.InputSignal<NbProgressTone>;
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly clampedValue: _angular_core.Signal<number>;
+    protected readonly percentage: _angular_core.Signal<number>;
+    protected readonly hostClass: _angular_core.Signal<string>;
+    protected readonly fillClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbProgress, "nb-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NbAvatarGroup {
+    readonly overflow: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbAvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbAvatarGroup, "nb-avatar-group", never, { "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type NbStickerShape = 'burst' | 'burst-wide' | 'star' | 'splat';
+type NbStickerTone = NbTone;
+
+interface NbStickerPathConfig {
+    viewBox: string;
+    path: string;
+    shadowTransform: string;
+}
+
+interface NbStickerToneTokens {
+    fill: string;
+    ink: string;
+    shadow: string;
+}
+declare class NbSticker {
+    readonly shape: _angular_core.InputSignal<NbStickerShape>;
+    readonly tone: _angular_core.InputSignal<_ng_brutalism_ui.NbTone>;
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rotate: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly config: _angular_core.Signal<NbStickerPathConfig>;
+    protected readonly toneTokens: _angular_core.Signal<NbStickerToneTokens>;
+    protected readonly rotateStyle: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSticker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbSticker, "nb-sticker", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "rotate": { "alias": "rotate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NbStickerFace {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbStickerFace, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbStickerFace, "nb-sticker-face", never, {}, {}, never, never, true, never>;
+}
+
+type NbHalftoneShape = 'square' | 'circle' | 'rectangle';
+declare class NbHalftone {
+    readonly shape: _angular_core.InputSignal<NbHalftoneShape>;
+    readonly color: _angular_core.InputSignal<string | null>;
+    readonly size: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly gap: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly gapX: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly gapY: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly rows: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly columns: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    protected readonly resolvedColor: _angular_core.Signal<string>;
+    protected readonly resolvedSize: _angular_core.Signal<number>;
+    protected readonly resolvedGap: _angular_core.Signal<number>;
+    protected readonly resolvedGapXInput: _angular_core.Signal<number | null>;
+    protected readonly resolvedGapYInput: _angular_core.Signal<number | null>;
+    protected readonly resolvedRows: _angular_core.Signal<number>;
+    protected readonly resolvedColumns: _angular_core.Signal<number>;
+    protected readonly svgW: _angular_core.Signal<number>;
+    protected readonly svgH: _angular_core.Signal<number>;
+    protected readonly dotR: _angular_core.Signal<number>;
+    protected readonly dots: _angular_core.Signal<{
+        cx: number;
+        cy: number;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbHalftone, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbHalftone, "nb-halftone, [nbHalftone]", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "gapX": { "alias": "gapX"; "required": false; "isSignal": true; }; "gapY": { "alias": "gapY"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NbSurfaceTone = NbToneToken;
+type NbSurfaceRadius = NbRadius;
+type NbSurfaceBorder = NbBorderStrength;
+type NbSurfaceShadow = NbShadow;
+type NbSurfacePadding = NbPadding;
+type NbSurfaceSize = 'auto' | 'sm' | 'md' | 'lg' | 'xl';
+type NbSurfaceLayout = 'block' | 'center' | 'row' | 'stack';
+type NbSurfaceEdge = 'none' | 'top' | 'bottom';
+declare class NbSurface {
+    readonly size: _angular_core.InputSignal<NbSurfaceSize>;
+    readonly layout: _angular_core.InputSignal<NbSurfaceLayout>;
+    readonly padding: _angular_core.InputSignal<NbPadding>;
+    readonly edge: _angular_core.InputSignal<NbSurfaceEdge>;
+    readonly clip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private sizeClass;
+    private layoutClass;
+    private edgeClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSurface, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbSurface, "[nbSurface]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "edge": { "alias": "edge"; "required": false; "isSignal": true; }; "clip": { "alias": "clip"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbRadiusCapability; inputs: { "radius": "radius"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }, { directive: typeof NbBorderCapability; inputs: { "border": "border"; }; outputs: {}; }, { directive: typeof NbPaddingCapability; inputs: { "padding": "padding"; }; outputs: {}; }, { directive: typeof NbTypography; inputs: { "font": "typography"; }; outputs: {}; }]>;
+}
+
+type NbStackGap = NbSpacing;
+type NbStackAlign = 'stretch' | 'start' | 'center' | 'end';
+type NbStackJustify = 'start' | 'center' | 'end' | 'between';
+type NbStackSeparator = 'none' | 'solid' | 'dashed' | 'thick';
+declare class NbStack {
+    readonly align: _angular_core.InputSignal<NbStackAlign>;
+    readonly justify: _angular_core.InputSignal<NbStackJustify>;
+    readonly separator: _angular_core.InputSignal<NbStackSeparator>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private alignClass;
+    private justifyClass;
+    private separatorClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbStack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbStack, "[nbStack]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbGapCapability; inputs: { "gap": "gap"; }; outputs: {}; }]>;
+}
+
+type NbClusterGap = NbSpacing;
+type NbClusterAlign = 'start' | 'center' | 'end' | 'baseline' | 'stretch';
+type NbClusterJustify = 'start' | 'center' | 'end' | 'between';
+type NbClusterWrap = 'wrap' | 'nowrap';
+type NbClusterSeparator = 'none' | 'solid' | 'dashed' | 'thick';
+declare class NbCluster {
+    readonly align: _angular_core.InputSignal<NbClusterAlign>;
+    readonly justify: _angular_core.InputSignal<NbClusterJustify>;
+    readonly wrap: _angular_core.InputSignal<NbClusterWrap>;
+    readonly separator: _angular_core.InputSignal<NbClusterSeparator>;
+    protected readonly separatorColumnGapStyle: _angular_core.Signal<"0px" | null>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private gapClass;
+    private alignClass;
+    private justifyClass;
+    private wrapClass;
+    private separatorClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCluster, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbCluster, "[nbCluster]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbGapCapability; inputs: { "gap": "gap"; }; outputs: {}; }, { directive: typeof NbPaddingCapability; inputs: { "padding": "padding"; }; outputs: {}; }]>;
+}
+
+type NbSplitRatio = '1:1' | '2:1' | '3:1' | '1:2' | '1:3' | 'fill:auto' | 'auto:fill';
+type NbSplitGap = NbSpacing;
+type NbSplitPadding = NbPadding;
+type NbSplitCollapse = 'none' | 'sm' | 'md' | 'lg';
+type NbSplitAlign = 'start' | 'center' | 'end' | 'stretch';
+type NbSplitSeparator = 'none' | 'solid' | 'dashed' | 'thick';
+declare class NbSplit {
+    readonly ratio: _angular_core.InputSignal<NbSplitRatio>;
+    readonly collapse: _angular_core.InputSignal<NbSplitCollapse>;
+    readonly align: _angular_core.InputSignal<NbSplitAlign>;
+    readonly separator: _angular_core.InputSignal<NbSplitSeparator>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private alignClass;
+    private ratioClass;
+    private collapseClass;
+    private separatorClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSplit, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbSplit, "[nbSplit]", never, { "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbGapCapability; inputs: { "gap": "gap"; }; outputs: {}; }, { directive: typeof NbPaddingCapability; inputs: { "padding": "padding"; }; outputs: {}; }]>;
+}
+
+type NbSectionPadding = NbPadding;
+type NbSectionDivider = NbDivider;
+type NbSectionDividerStyle = 'solid' | 'dashed' | 'dotted';
+type NbSectionLayout = 'default' | 'center' | 'between';
+type NbSectionAlign = 'stretch' | 'start' | 'center' | 'end';
+declare class NbSection {
+    readonly divider: _angular_core.InputSignal<NbDivider>;
+    readonly dividerStyle: _angular_core.InputSignal<NbSectionDividerStyle>;
+    readonly layout: _angular_core.InputSignal<NbSectionLayout>;
+    readonly align: _angular_core.InputSignal<NbSectionAlign>;
+    readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private layoutClass;
+    private alignClass;
+    private dividerClass;
+    private dividerStyleClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbSection, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbSection, "[nbSection]", ["nbSection"], { "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "dividerStyle": { "alias": "dividerStyle"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbPaddingCapability; inputs: { "padding": "padding"; }; outputs: {}; }]>;
+}
+
+type NbCalloutTone = NbToneToken;
+type NbCalloutSize = 'sm' | 'md' | 'lg' | 'xl';
+type NbCalloutLayout = 'inline' | 'between' | 'center';
+type NbCalloutShadow = 'none' | 'default' | 'hard';
+declare class NbCallout {
+    readonly size: _angular_core.InputSignal<NbCalloutSize>;
+    readonly layout: _angular_core.InputSignal<NbCalloutLayout>;
+    readonly radius: _angular_core.InputSignal<NbRadius | undefined>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly radiusStyle: _angular_core.Signal<string | null>;
+    private sizeClass;
+    private layoutClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbCallout, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbCallout, "[nbCallout]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }, { directive: typeof NbShadowCapability; inputs: { "shadow": "shadow"; }; outputs: {}; }]>;
+}
+
+type NbMediaItemVariant = 'plain' | 'boxed' | 'chip';
+type NbMediaItemOrientation = 'horizontal' | 'vertical';
+type NbMediaItemAlign = 'start' | 'center' | 'between';
+type NbMediaItemSize = 'xs' | 'sm' | 'md' | 'lg';
+type NbMediaItemTone = NbToneToken;
+declare class NbMediaItem {
+    readonly variant: _angular_core.InputSignal<NbMediaItemVariant>;
+    readonly orientation: _angular_core.InputSignal<NbMediaItemOrientation>;
+    readonly align: _angular_core.InputSignal<NbMediaItemAlign>;
+    readonly size: _angular_core.InputSignal<NbMediaItemSize>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly iconAlt: _angular_core.InputSignal<string>;
+    readonly iconBackground: _angular_core.InputSignal<string | undefined>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly iconClasses: _angular_core.Signal<string>;
+    private variantClass;
+    private orientationClass;
+    private alignClass;
+    private sizeClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMediaItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NbMediaItem, "nb-media-item, [nbMediaItem]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconAlt": { "alias": "iconAlt"; "required": false; "isSignal": true; }; "iconBackground": { "alias": "iconBackground"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["nb-media-item-icon, [nbMediaItemIcon], [nbSurface], img, svg", "nb-media-item-title, [nbMediaItemTitle]", "nb-media-item-description, [nbMediaItemDescription]", "*", "nb-media-item-action, [nbMediaItemAction]"], true, [{ directive: typeof NbToneCapability; inputs: { "tone": "tone"; }; outputs: {}; }]>;
+}
+declare class NbMediaItemIcon {
+    readonly surface: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly background: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMediaItemIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbMediaItemIcon, "nb-media-item-icon, [nbMediaItemIcon]", never, { "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NbMediaItemTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMediaItemTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbMediaItemTitle, "nb-media-item-title, [nbMediaItemTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class NbMediaItemDescription {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NbMediaItemDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NbMediaItemDescription, "nb-media-item-description, [nbMediaItemDescription]", never, {}, {}, never, never, true, never>;
 }
 
-export { NB_THEME_CONFIG, NbAccordion, NbAccordionContent, NbAccordionItem, NbAccordionTrigger, NbAvatar, NbBadge, NbButton, NbCard, NbCardActions, NbCardContent, NbCardDescription, NbCardFooter, NbCardHeader, NbCardTitle, NbCheckbox, NbDialog, NbDialogActions, NbDialogClose, NbDialogContent, NbDialogDescription, NbDialogTitle, NbImageCard, NbImageCardCaption, NbInput, NbInputGroup, NbInputPrefix, NbInputSuffix, NbLabel, NbMarquee, NbMarqueeItem, NbNativeSelect, NbSelect, NbSelectOption, NbTextarea, NbTitle, nbClass, provideNgBrutalism };
-export type { NbAccordionType, NbAccordionValue, NbBadgeVariant, NbButtonShadow, NbButtonSize, NbButtonVariant, NbCardActionsAlign, NbCheckboxSize, NbConfig, NbInputPrefixAlign, NbInputSize, NbInputSuffixAlign, NbSelectValue, NbTextareaSize, NbThemeConfig };
+export { NB_THEME_CONFIG, NbAccordion, NbAccordionContent, NbAccordionItem, NbAccordionTrigger, NbAvatar, NbAvatarGroup, NbBadge, NbButton, NbButtonTrailingIcon, NbCallout, NbCard, NbCardActions, NbCardContent, NbCardDescription, NbCardFooter, NbCardHeader, NbCardTitle, NbCheckbox, NbChip, NbChipGroup, NbCluster, NbDialog, NbDialogActions, NbDialogClose, NbDialogContent, NbDialogDescription, NbDialogTitle, NbDisplay, NbHalftone, NbIcon, NbIconButton, NbImageCard, NbImageCardCaption, NbInput, NbInputGroup, NbInputPrefix, NbInputSuffix, NbLabel, NbMarquee, NbMarqueeItem, NbMediaFrame, NbMediaItem, NbMediaItemDescription, NbMediaItemIcon, NbMediaItemTitle, NbNativeSelect, NbProgress, NbRating, NbSection, NbSelect, NbSelectOption, NbSeparator, NbSplit, NbStack, NbStat, NbStatusDot, NbSticker, NbStickerFace, NbSurface, NbText, NbTextarea, NbTitle, NbTypography, nbBorderWidthValue, nbClass, nbFontWeightValue, nbPaddingValue, nbRadiusValue, nbShadowValue, nbSpacingValue, nbToneTokens, nbToneVars, nbTypographyFontValue, nbUnderlineGapValue, nbUnderlineWidthValue, provideNgBrutalism, NB_STYLE_DEFAULTS as ɵNB_STYLE_DEFAULTS, NB_STYLE_NAMESPACE as ɵNB_STYLE_NAMESPACE, NbBorderCapability as ɵNbBorderCapability, NbGapCapability as ɵNbGapCapability, NbPaddingCapability as ɵNbPaddingCapability, NbRadiusCapability as ɵNbRadiusCapability, NbResetMarginCapability as ɵNbResetMarginCapability, NbShadowCapability as ɵNbShadowCapability, NbToneCapability as ɵNbToneCapability, NbUnderlineCapability as ɵNbUnderlineCapability };
+export type { NbAccordionType, NbAccordionValue, NbAvatarBorder, NbAvatarRadius, NbAvatarShadow, NbAvatarTone, NbBadgeBorder, NbBadgeRadius, NbBadgeShadow, NbBadgeTone, NbBorderStrength, NbButtonIconPush, NbButtonIconShape, NbButtonIconSize, NbButtonIconTone, NbButtonPress, NbButtonRadius, NbButtonShadow, NbButtonSize, NbButtonTone, NbCalloutLayout, NbCalloutShadow, NbCalloutSize, NbCalloutTone, NbCardActionsAlign, NbCardBorder, NbCardRadius, NbCardShadow, NbCardTone, NbCheckboxSize, NbChipGroupAlign, NbChipGroupDirection, NbChipPadding, NbChipTone, NbClusterAlign, NbClusterGap, NbClusterJustify, NbClusterSeparator, NbClusterWrap, NbConfig, NbDisplayLeading, NbDisplaySize, NbDisplayTracking, NbDisplayUnderline, NbDisplayWeight, NbDivider, NbFontWeight, NbHalftoneShape, NbIconButtonShape, NbIconButtonSize, NbIconMode, NbIconSize, NbIconTone, NbImageCardBorder, NbImageCardRadius, NbImageCardShadow, NbImageCardTone, NbInputPrefixAlign, NbInputSize, NbInputSuffixAlign, NbMediaFrameBorder, NbMediaFrameFit, NbMediaFrameRadius, NbMediaFrameRatio, NbMediaFrameShadow, NbMediaFrameTone, NbMediaItemAlign, NbMediaItemOrientation, NbMediaItemSize, NbMediaItemTone, NbMediaItemVariant, NbPadding, NbProgressTone, NbRadius, NbSectionAlign, NbSectionDivider, NbSectionDividerStyle, NbSectionLayout, NbSectionPadding, NbSelectValue, NbSeparatorOrientation, NbSeparatorVariant, NbShadow, NbSpacing, NbSplitAlign, NbSplitCollapse, NbSplitGap, NbSplitPadding, NbSplitRatio, NbSplitSeparator, NbStackAlign, NbStackGap, NbStackJustify, NbStackSeparator, NbStatusDotState, NbStickerShape, NbStickerTone, NbSurfaceBorder, NbSurfaceEdge, NbSurfaceLayout, NbSurfacePadding, NbSurfaceRadius, NbSurfaceShadow, NbSurfaceSize, NbSurfaceTone, NbTextLeading, NbTextMeasure, NbTextSize, NbTextTone, NbTextTracking, NbTextTransform, NbTextWeight, NbTextareaSize, NbThemeConfig, NbTone, NbToneToken, NbToneTokens, NbToneVars, NbTypographyFont, NbUnderlineGap, NbUnderlineVariant, NbUnderlineWidth, NbStyleDefaults as ɵNbStyleDefaults };