@ng-brutalism/ui 0.1.0

package/schematics/ng-add/schema.d.ts

@@ -0,0 +1,3 @@
+export interface NgAddSchema {
+    project?: string;
+}

package/schematics/ng-add/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map

package/schematics/ng-add/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../libs/schematics/src/ng-add/schema.ts"],"names":[],"mappings":""}

package/schematics/ng-add/schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "@ng-brutalism/ui ng-add",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The Angular CLI application project to configure.",
+      "$default": {
+        "$source": "projectName"
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/schematics/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/styles.css

@@ -0,0 +1,162 @@
+/* styles.css - full theme + base reset */
+@import './theme.css';
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+body {
+  background-color: var(--nb-background);
+  color: var(--nb-foreground);
+  font-family: var(--nb-font-sans);
+  font-weight: var(--nb-font-weight-normal);
+}
+
+/* Zero-specificity defaults: any consumer Tailwind utility on the element wins
+   without needing the `!` (important) suffix. Tokens are exposed for theming.
+   Wrapped in @layer base so Tailwind v4 utilities (in @layer utilities) win
+   over these unlayered defaults — without this, the cascade-layer rule
+   "unlayered author > layered author" makes the :where() rule beat any
+   utility regardless of specificity. */
+
+@layer base {
+  :where([data-slot="dialog-title"]) {
+    display: block;
+    padding: 1.5rem 1.5rem 0.5rem;
+    font-size: 1.125rem;
+    font-weight: 700;
+    line-height: 1;
+  }
+
+  :where([data-nb-title])::after {
+    content: "";
+    display: block;
+    width: var(--nb-title-wave-width, min(18rem, 100%));
+    height: var(--nb-title-wave-height, 0.625rem);
+    margin-top: var(--nb-title-wave-gap, 0);
+    background-color: var(--nb-title-wave-color, #a78bfa);
+    -webkit-mask: url("data:image/svg+xml,%3Csvg viewBox='0 0 220 12' preserveAspectRatio='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M0,6 Q10,0 20,6 T40,6 T60,6 T80,6 T100,6 T120,6 T140,6 T160,6 T180,6 T200,6 T220,6' fill='none' stroke='black' stroke-width='6' stroke-linecap='round'/%3E%3C/svg%3E")
+      center / 100% 100% no-repeat;
+    mask: url("data:image/svg+xml,%3Csvg viewBox='0 0 220 12' preserveAspectRatio='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M0,6 Q10,0 20,6 T40,6 T60,6 T80,6 T100,6 T120,6 T140,6 T160,6 T180,6 T200,6 T220,6' fill='none' stroke='black' stroke-width='6' stroke-linecap='round'/%3E%3C/svg%3E")
+      center / 100% 100% no-repeat;
+  }
+
+  :where([data-slot="dialog-description"]) {
+    display: block;
+    padding: 0 1.5rem 1rem;
+    font-size: 0.875rem;
+    font-weight: 500;
+    color: var(--nb-dialog-description-fg);
+  }
+
+  :where([data-slot="dialog-content"]) {
+    flex: 1 1 0%;
+    overflow-y: auto;
+    padding: 1rem 1.5rem;
+    border-top: 2px solid var(--nb-border);
+    border-bottom: 2px solid var(--nb-border);
+    background-color: var(--nb-dialog-content-bg);
+  }
+
+  :where([data-slot="dialog-actions"]) {
+    display: flex;
+    align-items: center;
+    justify-content: flex-end;
+    gap: 0.75rem;
+    padding: 1rem 1.5rem;
+    background-color: var(--nb-dialog-actions-bg);
+  }
+
+  :where(input[nbInput], textarea[nbTextarea]) {
+    background-color: var(--nb-input-bg, var(--nb-field-bg));
+  }
+
+  :where(input[nbInput]) {
+    height: 2.5rem;
+    padding: 0.5rem 0.75rem;
+    font-size: 0.875rem;
+  }
+  :where(input[nbInput][data-size="sm"]) {
+    height: 2.25rem;
+    padding: 0 0.75rem;
+  }
+  :where(input[nbInput][data-size="lg"]) {
+    height: 2.75rem;
+    padding: 0 1rem;
+    font-size: 1rem;
+  }
+
+  :where(input[nbInput][type="file"]) {
+    padding-block: 0;
+    padding-inline-start: 0;
+    align-items: center;
+  }
+  :where(input[nbInput][type="file"])::file-selector-button {
+    font-family: inherit;
+    background-color: var(--nb-main);
+  }
+
+  :where([nbInputPrefix]:has(svg)) {
+    --nb-input-group-prefix-bg: #ffd24a;
+  }
+
+  :where(select[nbSelect]) {
+    height: 3.5rem;
+    padding: 0.875rem 1.25rem;
+    font-family: var(--nb-font-mono, monospace);
+    font-size: 1rem;
+    font-weight: 700;
+    background-color: var(
+      --nb-select-bg,
+      var(--nb-input-bg, var(--nb-field-bg))
+    );
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23000000' stroke-width='2.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 1rem center;
+    background-size: 1.5rem 1.5rem;
+  }
+
+  :where(textarea[nbTextarea]) {
+    min-height: 5rem;
+    padding: 0.5rem 0.75rem;
+    font-size: 0.875rem;
+  }
+  :where(textarea[nbTextarea][data-size="sm"]) {
+    min-height: 4rem;
+    padding: 0.375rem 0.75rem;
+  }
+  :where(textarea[nbTextarea][data-size="lg"]) {
+    min-height: 6rem;
+    padding: 0.75rem 1rem;
+    font-size: 1rem;
+  }
+
+  :where(label[nbLabel]) {
+    font-size: 0.875rem;
+  }
+}
+
+/* Focus visible utility class */
+.nb-focus-visible:focus-visible {
+  outline: var(--nb-focus-ring);
+  outline-offset: var(--nb-focus-ring-offset);
+}
+
+.focus-visible\:outline-\[var\(--nb-focus-ring\)\]:focus-visible {
+  outline: var(--nb-focus-ring);
+}
+
+/* Dialog backdrop */
+dialog[data-nb-dialog]::backdrop {
+  background: rgba(0, 0, 0, 0.45);
+}
+
+/* Checkbox: check icon shown over the checked background */
+input[nbCheckbox]:checked {
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23000000' stroke-width='3.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: center;
+  background-size: 100%;
+}

package/theme.css

@@ -0,0 +1,70 @@
+/* theme.css - CSS variables only, no selectors beyond :root and .dark */
+:root {
+  /* Colors */
+  --nb-background: #ffffff;
+  --nb-foreground: #000000;
+  --nb-border: #000000;
+  --nb-shadow: #000000;
+  --nb-main: oklch(90% 0.15 95);
+  --nb-main-foreground: oklch(10% 0 0);
+  --nb-surface: #ffffff;
+  --nb-surface-foreground: #000000;
+  --nb-secondary-background: oklch(96% 0 0);
+  --nb-field-bg: #faf3d6;
+
+  --nb-primary: #ff90e8;
+  --nb-primary-foreground: #000000;
+  --nb-secondary: #c8a2ff;
+  --nb-secondary-foreground: #000000;
+  --nb-accent: #8ae9ff;
+  --nb-accent-foreground: #000000;
+  --nb-danger: #ff4f8a;
+  --nb-danger-foreground: #000000;
+  --nb-success: #63e6be;
+  --nb-success-foreground: #000000;
+  --nb-warning: #ff9c42;
+  --nb-warning-foreground: #000000;
+
+  /* Shape */
+  --nb-radius: 0rem;
+  --nb-border-width: 2px;
+  --nb-shadow-offset-x: 4px;
+  --nb-shadow-offset-y: 4px;
+  --nb-reverse-shadow-offset-x: -4px;
+  --nb-reverse-shadow-offset-y: -4px;
+
+  /* Size scale */
+  --nb-size-sm: 2rem;
+  --nb-size-md: 2.5rem;
+  --nb-size-lg: 3rem;
+
+  /* Typography */
+  --nb-font-sans: system-ui, sans-serif;
+  --nb-font-mono: monospace;
+  --nb-font-weight-normal: 500;
+  --nb-font-weight-bold: 700;
+
+  /* Focus */
+  --nb-focus-ring: 3px solid var(--nb-foreground);
+  --nb-focus-ring-offset: 2px;
+}
+
+/* Dark mode */
+.dark {
+  --nb-background: #0a0a0a;
+  --nb-foreground: #ffffff;
+  --nb-border: #ffffff;
+  --nb-shadow: #ffffff;
+  --nb-surface: #1a1a1a;
+  --nb-surface-foreground: #ffffff;
+}
+
+/* Reduced motion */
+@media (prefers-reduced-motion: reduce) {
+  :root {
+    --nb-shadow-offset-x: 0px;
+    --nb-shadow-offset-y: 0px;
+    --nb-reverse-shadow-offset-x: 0px;
+    --nb-reverse-shadow-offset-y: 0px;
+  }
+}

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

@@ -0,0 +1,387 @@
+import { ClassValue } from 'clsx';
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Signal } from '@angular/core';
+
+/**
+ * Merges class names with Tailwind conflict resolution.
+ * Publicly exported for consumers extending library components.
+ *
+ * @example
+ * nbClass('px-2 px-4')              // -> 'px-4'
+ * nbClass('flex', condition && 'w-full') // -> 'flex w-full' or 'flex'
+ */
+declare function nbClass(...inputs: ClassValue[]): string;
+
+interface NbThemeConfig {
+    primary?: string;
+    secondary?: string;
+    accent?: string;
+    danger?: string;
+    success?: string;
+    warning?: string;
+    radius?: string;
+    borderWidth?: string;
+    shadowOffsetX?: string;
+    shadowOffsetY?: string;
+    fontSans?: string;
+    fontMono?: string;
+}
+declare const NB_THEME_CONFIG: InjectionToken<NbThemeConfig>;
+
+interface NbConfig {
+    theme?: NbThemeConfig;
+}
+declare function provideNgBrutalism(config?: NbConfig): EnvironmentProviders;
+
+type NbCheckboxSize = 'default' | 'sm' | 'lg';
+
+declare class NbCheckbox {
+    readonly size: i0.InputSignal<NbCheckboxSize>;
+    protected readonly classes: i0.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>;
+}
+
+declare class NbAccordionItem {
+    private readonly id;
+    readonly value: i0.InputSignal<string>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    private readonly accordion;
+    readonly triggerId: string;
+    readonly contentId: string;
+    readonly open: i0.Signal<boolean>;
+    protected readonly classes: i0.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>;
+}
+
+type NbAccordionType = 'single' | 'multiple';
+type NbAccordionValue = string | string[] | null;
+interface NbAccordionController {
+    isItemOpen(value: string): boolean;
+    toggleItem(value: string): void;
+}
+
+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[]>;
+    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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+type NbButtonVariant = 'default' | 'neutral' | 'primary' | 'secondary' | 'accent' | 'danger' | 'success' | 'warning';
+type NbButtonShadow = 'default' | 'none' | 'reverse';
+type NbButtonSize = 'default' | 'sm' | 'lg' | 'icon';
+
+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;
+    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>;
+}
+
+type NbCardActionsAlign = 'start' | 'end';
+declare class NbCard {
+    protected readonly classes: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NbCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NbCard, "nb-card", never, {}, {}, never, ["*"], true, never>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+
+declare class NbImageCard {
+    readonly image: i0.InputSignal<string>;
+    readonly alt: i0.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>;
+}
+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>;
+}
+
+declare class NbMarquee {
+    readonly duration: i0.InputSignal<string>;
+    readonly reverse: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly pauseOnHover: i0.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<{
+        '--nb-marquee-duration': string;
+    }>;
+    private readonly scaledDuration;
+    protected readonly strip1Class: i0.Signal<string>;
+    protected readonly strip2Class: i0.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>;
+}
+
+declare class NbMarqueeItem {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NbMarqueeItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NbMarqueeItem, "nb-marquee-item", never, {}, {}, never, ["*"], true, never>;
+}
+
+type NbInputSize = 'default' | 'sm' | 'lg';
+
+declare class NbInput {
+    readonly size: i0.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>;
+}
+
+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>;
+}
+
+declare class NbTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NbTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NbTitle, "[nbTitle]", never, {}, {}, never, never, true, never>;
+}
+
+type NbTextareaSize = 'default' | 'sm' | 'lg';
+
+declare class NbTextarea {
+    readonly size: i0.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>;
+}
+
+interface NbInputGroupContext {
+    readonly hasPrefix: Signal<boolean>;
+    readonly hasSuffix: Signal<boolean>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+type NbSelectValue = string | number;
+interface NbSelectController {
+    readonly disabled: () => boolean;
+    readonly listboxId: string;
+    isSelected(value: NbSelectValue | null): boolean;
+    selectOption(option: NbSelectOption): void;
+    focusPreviousOption(current: NbSelectOption): void;
+    focusNextOption(current: NbSelectOption): void;
+    closeAndFocusTrigger(): void;
+}
+
+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>;
+    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>;
+}
+
+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[]>;
+    private readonly trigger;
+    readonly open: i0.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 listboxClasses: string;
+    isSelected(value: NbSelectValue | null): boolean;
+    selectOption(option: NbSelectOption): void;
+    toggle(): void;
+    openAndFocusOption(): void;
+    closeAndFocusTrigger(): void;
+    focusPreviousOption(current: NbSelectOption): void;
+    focusNextOption(current: NbSelectOption): void;
+    openListboxOnKey(event: KeyboardEvent): void;
+    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>;
+}
+
+type NbBadgeVariant = 'default' | 'secondary' | 'success' | 'warning' | 'danger';
+
+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>;
+}
+
+declare class NbAvatar {
+    readonly src: i0.InputSignal<string | undefined>;
+    readonly alt: i0.InputSignal<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>;
+}
+
+interface NbDialogController {
+    open(): void;
+    close(): void;
+}
+
+declare class NbDialog implements NbDialogController {
+    private readonly isBrowser;
+    private readonly dialogEl;
+    protected readonly classes: string;
+    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>;
+}
+
+declare class NbDialogTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogTitle, never>;
+    static ɵdir: i0.ɵɵ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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class NbDialogClose {
+    protected readonly controller: NbDialogController;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NbDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NbDialogClose, "[nbDialogClose]", 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 };