npm - @resolve-components/theme - Versions diffs - 1.0.0 - Mend

@resolve-components/theme 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/README.md +7 -0
package/collection.json +10 -0
package/fesm2022/resolve-components-theme.mjs +8946 -0
package/fesm2022/resolve-components-theme.mjs.map +1 -0
package/package.json +45 -0
package/schematics/ng-add/index.js +147 -0
package/schematics/ng-add/schema.json +15 -0
package/src/lib/styles/_all.scss +52 -0
package/src/lib/styles/_globals.scss +66 -0
package/src/lib/styles/_themes.scss +9 -0
package/src/lib/styles/_theming.scss +20 -0
package/src/lib/styles/themes/_dark.scss +107 -0
package/src/lib/styles/themes/_default.scss +341 -0
package/src/lib/styles/theming/_animation.scss +92 -0
package/src/lib/styles/theming/_functions.scss +34 -0
package/src/lib/styles/theming/_get-value.scss +70 -0
package/src/lib/styles/theming/_install.scss +141 -0
package/src/lib/styles/theming/_mapping.scss +701 -0
package/src/lib/styles/theming/_register.scss +58 -0
package/src/lib/styles/theming/_theming-variables.scss +30 -0
package/types/resolve-components-theme.d.ts +3214 -0

package/types/resolve-components-theme.d.ts ADDED Viewed

@@ -0,0 +1,3214 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, Renderer2, ModuleWithProviders, EventEmitter, OnChanges, TemplateRef, Injector, Type, ComponentRef, OnInit, ElementRef, AfterContentInit, SimpleChanges, QueryList, AfterViewInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/common';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import * as _resolve_components_theme from '@resolve-components/theme';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { CdkTable, CdkColumnDef, CdkHeaderCellDef, CdkCellDef, CdkFooterCellDef, CdkHeaderRowDef, CdkRowDef, CdkFooterRowDef, CdkHeaderRow, CdkRow, CdkFooterRow, CdkNoDataRow } from '@angular/cdk/table';
+import { DataSource } from '@angular/cdk/collections';
+import { ControlValueAccessor } from '@angular/forms';
+export { CdkVirtualForOf as RcVirtualForOf } from '@angular/cdk/scrolling';
+/**
+ * Configuration options for the Resolve Components theme system.
+ */
+interface RcThemeOptions {
+    /** Name of the initial theme (must match a registered theme). */
+    name: string;
+}
+/**
+ * A single variable entry in a JS theme.
+ */
+interface RcJSThemeVariable {
+    [key: string]: string | number | RcJSThemeVariable;
+}
+/**
+ * JS-accessible theme definition.
+ * These are simplified versions of the full SCSS theme — they provide
+ * key variables to JS consumers (charts, dynamic styling, etc.).
+ */
+interface RcJSThemeOptions {
+    /** Unique theme name. */
+    name: string;
+    /** Parent theme name to inherit from. */
+    base?: string;
+    /** Theme variables accessible from TypeScript. */
+    variables?: RcJSThemeVariable;
+}
+/** Injection token for theme configuration options. */
+declare const RC_THEME_OPTIONS: InjectionToken<RcThemeOptions>;
+/** Injection token for built-in JS theme definitions. */
+declare const RC_BUILT_IN_JS_THEMES: InjectionToken<RcJSThemeOptions[]>;
+/** Injection token for user-provided JS theme definitions. */
+declare const RC_JS_THEMES: InjectionToken<RcJSThemeOptions[]>;
+/**
+ * Registry for JS-accessible theme definitions.
+ *
+ * Merges built-in themes with user-provided themes at initialization.
+ * Supports theme inheritance via the `base` property.
+ *
+ * @example
+ * ```typescript
+ * const theme = this.registry.get('default');
+ * console.log(theme.variables.primary); // '#0078D4'
+ * ```
+ */
+declare class RcJSThemesRegistry {
+    private themes;
+    constructor(builtInThemes: RcJSThemeOptions[], newThemes: RcJSThemeOptions[]);
+    /**
+     * Register a theme, optionally inheriting from a base theme.
+     */
+    register(config: RcJSThemeOptions, themeName: string, baseThemeName?: string): void;
+    /**
+     * Whether a theme with the given name is registered.
+     */
+    has(themeName: string): boolean;
+    /**
+     * Get a deep copy of a registered theme by name.
+     */
+    get(themeName: string): RcJSThemeOptions;
+    /**
+     * Combine two theme arrays, preferring items from `newThemes` when
+     * names collide.
+     */
+    private combineByNames;
+    /**
+     * Deep merge objects (not arrays).
+     */
+    private mergeDeep;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcJSThemesRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RcJSThemesRegistry>;
+}
+/**
+ * Event emitted when the theme changes.
+ */
+interface RcThemeChange {
+    /** Name of the newly activated theme. */
+    name: string;
+    /** Name of the previously active theme (null on first activation). */
+    previous: string | null;
+}
+/**
+ * Central service for managing the active theme at runtime.
+ *
+ * Switching themes toggles a CSS class on `<body>` (`rc-theme-{name}`),
+ * which activates the corresponding CSS custom property block emitted
+ * during SCSS compilation.
+ *
+ * @example
+ * ```typescript
+ * // Switch to dark theme
+ * this.themeService.changeTheme('dark');
+ *
+ * // React to theme changes
+ * this.themeService.onThemeChange().subscribe(change => {
+ *   console.log(`Switched from ${change.previous} to ${change.name}`);
+ * });
+ *
+ * // Access JS theme variables (for charts, etc.)
+ * this.themeService.getJsTheme().subscribe(theme => {
+ *   const primaryColor = theme.variables?.primary;
+ * });
+ * ```
+ */
+declare class RcThemeService {
+    protected options: RcThemeOptions;
+    protected jsThemesRegistry: RcJSThemesRegistry;
+    /** Name of the currently active theme. */
+    currentTheme: string | null;
+    private themeChanges$;
+    private destroy$;
+    constructor(options: RcThemeOptions, jsThemesRegistry: RcJSThemesRegistry);
+    /**
+     * Switch the active theme.
+     * @param name - Registered theme name.
+     */
+    changeTheme(name: string): void;
+    /**
+     * Observable stream of theme change events.
+     */
+    onThemeChange(): Observable<RcThemeChange>;
+    /**
+     * Get the JS theme variables for the currently active theme.
+     * Emits whenever the theme changes.
+     */
+    getJsTheme(): Observable<RcJSThemeOptions>;
+    /**
+     * Get the JS theme variables for a specific theme by name.
+     */
+    getJsThemeByName(name: string): RcJSThemeOptions;
+    /**
+     * Clean up subscriptions.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RcThemeService>;
+}
+/**
+ * Layout component that bridges the theme service to the DOM.
+ *
+ * It subscribes to `RcThemeService.onThemeChange()` and toggles the
+ * CSS class `rc-theme-{name}` on `<body>`. This activates the
+ * corresponding CSS custom property block emitted by `rc-install()`.
+ *
+ * Place this component at the root of your application layout:
+ *
+ * @example
+ * ```html
+ * <rc-layout>
+ *   <router-outlet></router-outlet>
+ * </rc-layout>
+ * ```
+ */
+declare class RcLayout implements OnDestroy {
+    private themeService;
+    private renderer;
+    private document;
+    private destroy$;
+    constructor(themeService: RcThemeService, renderer: Renderer2, document: Document);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcLayout, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcLayout, "rc-layout", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Core theme module for Resolve Components.
+ *
+ * Call `.forRoot()` once at the application root to configure theming.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts (standalone)
+ * import { provideRcTheme } from '@resolve-components';
+ *
+ * export const appConfig = {
+ *   providers: [provideRcTheme({ name: 'default' })],
+ * };
+ *
+ * // or in NgModule style:
+ * @NgModule({
+ *   imports: [RcThemeModule.forRoot({ name: 'default' })],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class RcThemeModule {
+    constructor(parentModule: RcThemeModule);
+    /**
+     * Configure the theme system at the application root.
+     *
+     * @param rcThemeOptions - Initial theme configuration.
+     * @param rcJSThemes - Optional additional JS theme definitions.
+     */
+    static forRoot(rcThemeOptions?: RcThemeOptions, rcJSThemes?: RcJSThemeOptions[]): ModuleWithProviders<RcThemeModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcThemeModule, [{ optional: true; skipSelf: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RcThemeModule, never, [typeof i1.CommonModule, typeof RcLayout], [typeof RcLayout]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RcThemeModule>;
+}
+/**
+ * Standalone provider function for the Resolve Components theme system.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [provideRcTheme({ name: 'default' })],
+ * };
+ * ```
+ *
+ * @param options - Theme configuration.
+ * @param customThemes - Optional additional JS theme definitions.
+ */
+declare function provideRcTheme(options?: RcThemeOptions, customThemes?: RcJSThemeOptions[]): (typeof RcJSThemesRegistry | typeof RcThemeService | {
+    provide: i0.InjectionToken<RcThemeOptions>;
+    useValue: RcThemeOptions;
+} | {
+    provide: i0.InjectionToken<RcJSThemeOptions[]>;
+    useValue: RcJSThemeOptions[];
+})[];
+/**
+ * Default JS theme — Microsoft Fluent-inspired light palette.
+ * These variables are available at runtime for chart libraries, dynamic
+ * styling, or any JS consumer that needs theme colors.
+ */
+declare const DEFAULT_THEME: RcJSThemeOptions;
+/**
+ * Dark JS theme — inherits from default, overrides for dark surfaces.
+ */
+declare const DARK_THEME: RcJSThemeOptions;
+/**
+ * Root container component for Resolve Components design system.
+ * Provides a wrapper element with the `rc-root` class.
+ *
+ * @example
+ * ```html
+ * <rc-resolve-components>
+ *   <rc-button>Click me</rc-button>
+ * </rc-resolve-components>
+ * ```
+ */
+declare class ResolveComponents {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveComponents, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResolveComponents, "rc-resolve-components", never, {}, {}, never, never, true, never>;
+}
+/** Shape / visual style of the button. */
+type RcButtonVariant = 'filled' | 'outline' | 'ghost';
+/** Semantic colour / importance of the button. */
+type RcButtonStatus = 'primary' | 'secondary' | 'danger' | 'info' | 'success' | 'warning';
+type RcButtonSize = 'sm' | 'md' | 'lg';
+/**
+ * Directive for styling native button-like elements with Resolve design tokens.
+ *
+ * Apply `rcButton` to any `<button>`, `<a>`, or `<input type="submit">` element.
+ * The host element receives the full button styling including BEM modifier classes.
+ *
+ * @example Basic usage
+ * ```html
+ * <button rcButton>Default (filled primary)</button>
+ * <button rcButton status="danger">Delete</button>
+ * <button rcButton variant="outline">Outline primary</button>
+ * <button rcButton variant="outline" status="danger">Outline danger</button>
+ * <button rcButton variant="ghost" status="success">Ghost success</button>
+ * ```
+ *
+ * @example With icon (using rc-icon)
+ * ```html
+ * <button rcButton>
+ *   <rc-icon name="save"></rc-icon>
+ *   Save
+ * </button>
+ * ```
+ *
+ * @example Icon-only button
+ * ```html
+ * <button rcButton [iconOnly]="true">
+ *   <rc-icon name="plus"></rc-icon>
+ * </button>
+ * ```
+ *
+ * @example Link button
+ * ```html
+ * <a rcButton variant="outline" href="/dashboard">Dashboard</a>
+ * ```
+ *
+ * @example Submit form
+ * ```html
+ * <input rcButton type="submit" value="Submit" />
+ * ```
+ *
+ * @input variant  - Visual shape: `'filled'` | `'outline'` | `'ghost'`. Default: `'filled'`
+ * @input status   - Semantic colour: `'primary'` | `'secondary'` | `'danger'` | `'info'` | `'success'` | `'warning'`. Default: `'primary'`
+ * @input size     - Button size: `'sm'` | `'md'` | `'lg'`. Default: `'md'`
+ * @input disabled - Whether the element is disabled. Default: `false`
+ * @input iconOnly - Renders as a square icon-only button. Default: `false`
+ * @output clicked - Emits `MouseEvent` when clicked and not disabled.
+ *
+ * Variants (shape):
+ * - `filled`  Solid background — default
+ * - `outline` Transparent with coloured border
+ * - `ghost`   Fully transparent, hover reveals background
+ *
+ * Status (colour):
+ * - `primary`   Blue  — main call-to-action
+ * - `secondary` Gray  — secondary / neutral action
+ * - `danger`    Red   — destructive / irreversible action
+ * - `info`      Teal  — informational action
+ * - `success`   Green — confirm / complete
+ * - `warning`   Amber — cautionary action
+ */
+declare class RcButtonComponent {
+    /** Visual shape of the button */
+    variant: RcButtonVariant;
+    /** Semantic colour / importance */
+    status: RcButtonStatus;
+    /** Button size */
+    size: RcButtonSize;
+    /** Whether the element is disabled */
+    disabled: boolean;
+    /** Render as a square icon-only button (no padding, equal width/height) */
+    iconOnly: boolean;
+    /** Emits when the element is clicked and not disabled */
+    clicked: EventEmitter<MouseEvent>;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcButtonComponent, "button[rcButton], a[rcButton], input[type=submit][rcButton], input[type=button][rcButton], input[type=reset][rcButton]", never, { "variant": { "alias": "variant"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+/** Colour status of the badge. */
+type RcBadgeStatus = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+/** @deprecated Use `RcBadgeStatus` instead. */
+type RcBadgeVariant = RcBadgeStatus;
+type RcBadgeSize = 'sm' | 'md';
+/**
+ * A small inline label for displaying status, counts, or category tags.
+ *
+ * @example
+ * ```html
+ * <rc-badge>Default</rc-badge>
+ * <rc-badge status="primary">New</rc-badge>
+ * <rc-badge status="success" size="sm">Active</rc-badge>
+ * <rc-badge status="warning">Pending</rc-badge>
+ * <rc-badge status="danger">Error</rc-badge>
+ * ```
+ */
+declare class RcBadgeComponent {
+    /** Colour status of the badge. */
+    status: RcBadgeStatus;
+    /** Badge size. */
+    size: RcBadgeSize;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcBadgeComponent, "rc-badge", never, { "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * A card container component for the Resolve design system.
+ *
+ * @example
+ * ```html
+ * <rc-card>
+ *   <h3 rc-card-title>Card Title</h3>
+ *   <p>Card content goes here.</p>
+ * </rc-card>
+ *
+ * <rc-card [padding]="false" [shadow]="true">
+ *   <img src="cover.jpg" alt="Cover" />
+ * </rc-card>
+ * ```
+ *
+ * @input padding - Whether the card has inner padding. Default: `true`
+ * @input shadow - Whether the card has a box shadow. Default: `false`
+ * @input bordered - Whether the card has a border. Default: `true`
+ */
+declare class RcCardComponent {
+    /** Whether the card has inner padding */
+    padding: boolean;
+    /** Whether the card has a box shadow */
+    shadow: boolean;
+    /** Whether the card has a border */
+    bordered: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcCardComponent, "rc-card", never, { "padding": { "alias": "padding"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+type RcIconStatus = 'basic' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+/**
+ * Icon component backed by the Eva Icons SVG library (490+ icons).
+ *
+ * Renders inline SVG directly onto the host element using `fill="currentColor"`,
+ * so the icon inherits the current CSS `color` — perfect for use inside buttons,
+ * badges, and any themed context.
+ *
+ * @see https://akveo.github.io/eva-icons/
+ *
+ * @example Basic
+ * ```html
+ * <rc-icon name="star"></rc-icon>
+ * ```
+ *
+ * @example With status colour
+ * ```html
+ * <rc-icon name="checkmark-circle" status="success"></rc-icon>
+ * <rc-icon name="alert-circle" status="danger"></rc-icon>
+ * ```
+ *
+ * @example Custom size
+ * ```html
+ * <rc-icon name="home" style="font-size: 32px"></rc-icon>
+ * ```
+ *
+ * @example Inside a button
+ * ```html
+ * <button rcButton status="primary">
+ *   <rc-icon name="save"></rc-icon>
+ *   Save
+ * </button>
+ *
+ * <!-- Icon-only -->
+ * <button rcButton status="primary" [iconOnly]="true">
+ *   <rc-icon name="plus"></rc-icon>
+ * </button>
+ * ```
+ *
+ * @input name   - Eva Icons icon name (e.g. `'star'`, `'home'`, `'checkmark'`)
+ * @input status - Colour variant using semantic theme tokens. Default: `'basic'`
+ */
+declare class RcIconComponent implements OnChanges {
+    private sanitizer;
+    /** Eva Icons icon name */
+    name: string;
+    /**
+     * Colour status applied via theme CSS custom properties.
+     * `'basic'` inherits the surrounding text colour.
+     */
+    status: RcIconStatus;
+    svgHtml: SafeHtml;
+    constructor(sanitizer: DomSanitizer);
+    ngOnChanges(): void;
+    /** Returns all available Eva Icons names (useful for tooling / demo). */
+    static getIconNames(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcIconComponent, "rc-icon", never, { "name": { "alias": "name"; "required": true; }; "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
+}
+type RcTabStatus = 'basic' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+/**
+ * Individual tab definition used inside `<rc-tabs>`.
+ *
+ * Content projected into `<rc-tab>` is rendered inside the active tab panel.
+ *
+ * @example
+ * ```html
+ * <rc-tabs>
+ *   <rc-tab label="Overview" icon="home">...</rc-tab>
+ *   <rc-tab label="API" icon="code" status="primary">...</rc-tab>
+ *   <rc-tab label="Disabled" disabled>...</rc-tab>
+ * </rc-tabs>
+ * ```
+ */
+declare class RcTabComponent {
+    /** Tab header label text */
+    label: string;
+    /** Optional Eva Icons icon name shown before the label */
+    icon?: string;
+    /**
+     * Semantic status — colours the active tab indicator.
+     * `'basic'` uses the default primary colour.
+     */
+    status: RcTabStatus;
+    /** When true the tab header is non-interactive */
+    disabled: boolean;
+    /** @internal — referenced by RcTabsComponent to outlet content */
+    content: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcTabComponent, "rc-tab", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "status": { "alias": "status"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+type RcTabsSize = 'sm' | 'md' | 'lg';
+/**
+ * Tabs container. Place `<rc-tab>` children inside to define tabs.
+ *
+ * @example Basic
+ * ```html
+ * <rc-tabs>
+ *   <rc-tab label="Overview">Overview content</rc-tab>
+ *   <rc-tab label="API">API content</rc-tab>
+ * </rc-tabs>
+ * ```
+ *
+ * @example With icons and status
+ * ```html
+ * <rc-tabs size="sm">
+ *   <rc-tab label="Home"    icon="home"    status="primary">...</rc-tab>
+ *   <rc-tab label="Profile" icon="person"  status="success">...</rc-tab>
+ *   <rc-tab label="Danger"  icon="alert-triangle" status="danger">...</rc-tab>
+ *   <rc-tab label="Locked"  icon="lock"    [disabled]="true">...</rc-tab>
+ * </rc-tabs>
+ * ```
+ */
+declare class RcTabsComponent {
+    /** Query projected rc-tab children (signal-based, auto-updates) */
+    readonly tabs: i0.Signal<readonly RcTabComponent[]>;
+    /** Size variant — affects font size and padding */
+    size: RcTabsSize;
+    /** Programmatically set the active tab index */
+    set activeTab(index: number);
+    /** Emits the new tab index whenever the active tab changes */
+    tabChange: EventEmitter<number>;
+    protected readonly _activeIndex: i0.WritableSignal<number>;
+    readonly activeIndex: i0.Signal<number>;
+    select(index: number): void;
+    selectNext(): void;
+    selectPrev(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcTabsComponent, "rc-tabs", never, { "size": { "alias": "size"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; }, { "tabChange": "tabChange"; }, ["tabs"], never, true, never>;
+}
+type RcAlertStatus = 'info' | 'success' | 'warning' | 'danger';
+type RcAlertVariant = 'subtle' | 'filled' | 'outline';
+/**
+ * An inline contextual alert for displaying feedback messages.
+ *
+ * @example Basic
+ * ```html
+ * <rc-alert status="success">Changes saved successfully.</rc-alert>
+ * ```
+ *
+ * @example With title and dismissible
+ * ```html
+ * <rc-alert status="warning" title="Action required" [dismissible]="true" (dismissed)="onDismiss()">
+ *   Please review the highlighted fields.
+ * </rc-alert>
+ * ```
+ *
+ * @example Filled variant
+ * ```html
+ * <rc-alert status="danger" variant="filled" title="Error">
+ *   Unable to save changes. Please try again.
+ * </rc-alert>
+ * ```
+ *
+ * @input status      - Semantic status colour. Default: `'info'`
+ * @input variant     - Visual style. Default: `'subtle'`
+ * @input title       - Optional bold heading above the message.
+ * @input dismissible - Shows a close button. Default: `false`
+ * @output dismissed  - Emits when the close button is clicked.
+ */
+declare class RcAlertComponent {
+    /** Semantic status colour */
+    status: RcAlertStatus;
+    /** Visual style variant */
+    variant: RcAlertVariant;
+    /** Optional bold heading above the message */
+    title?: string;
+    /** Shows a close button when true */
+    dismissible: boolean;
+    /** ARIA label for the dismiss button. */
+    dismissAriaLabel: string;
+    /** Emitted when the close button is clicked */
+    dismissed: EventEmitter<void>;
+    get hostClasses(): string;
+    get statusIcon(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcAlertComponent, "rc-alert", never, { "status": { "alias": "status"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "title": { "alias": "title"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "dismissAriaLabel": { "alias": "dismissAriaLabel"; "required": false; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+type RcToastStatus = 'info' | 'success' | 'warning' | 'danger';
+type RcToastPosition = 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
+interface RcToastConfig {
+    /** The main message to display. */
+    message: string;
+    /** Optional bold heading above the message. */
+    title?: string;
+    /** Semantic status colour. Default: `'info'` */
+    status?: RcToastStatus;
+    /**
+     * Auto-dismiss delay in milliseconds.
+     * Set to `0` to keep the toast until manually dismissed.
+     * Default: `5000`
+     */
+    duration?: number;
+    /** Screen position for the toast stack. Default: `'top-right'` */
+    position?: RcToastPosition;
+    /** Whether to show a close button. Default: `true` */
+    dismissible?: boolean;
+    /** ARIA label for the dismiss button. Default: `'Dismiss notification'` */
+    dismissAriaLabel?: string;
+}
+/** Resolved config with all defaults applied. */
+interface RcToastRef {
+    /** Unique identifier for this toast instance. */
+    id: string;
+    config: Required<RcToastConfig>;
+}
+/**
+ * Service for displaying non-blocking toast notifications.
+ *
+ * Uses Angular CDK Overlay to render floating toast stacks at any of six
+ * screen positions. One overlay pane is created per position, lazily.
+ *
+ * ## Setup
+ * The service is `providedIn: 'root'` and works out of the box. Make sure
+ * `@angular/cdk/overlay-prebuilt.css` is imported in your global styles:
+ *
+ * ```scss
+ * // styles.scss
+ * @import '@angular/cdk/overlay-prebuilt.css';
+ * ```
+ *
+ * ## Usage
+ * ```typescript
+ * constructor(private toast: RcToastService) {}
+ *
+ * this.toast.success('Saved!', 'Success');
+ * this.toast.danger('Something went wrong.', 'Error');
+ * this.toast.show({ message: 'Custom toast', status: 'info', duration: 8000, position: 'bottom-center' });
+ * ```
+ */
+declare class RcToastService {
+    private overlay;
+    private injector;
+    private _toasts$;
+    /** Observable stream of all currently active toasts (across positions). */
+    readonly toasts$: Observable<RcToastRef[]>;
+    private _overlays;
+    private _containers;
+    private _subs;
+    constructor(overlay: Overlay, injector: Injector);
+    /**
+     * Show a toast notification with full configuration control.
+     */
+    show(config: RcToastConfig): RcToastRef;
+    /** Dismiss a toast by its id. */
+    dismiss(id: string): void;
+    /** Dismiss all active toasts, optionally filtered by position. */
+    dismissAll(position?: RcToastPosition): void;
+    /** Show a success toast. */
+    success(message: string, title?: string, config?: Partial<RcToastConfig>): RcToastRef;
+    /** Show an info toast. */
+    info(message: string, title?: string, config?: Partial<RcToastConfig>): RcToastRef;
+    /** Show a warning toast. */
+    warning(message: string, title?: string, config?: Partial<RcToastConfig>): RcToastRef;
+    /** Show a danger / error toast. */
+    danger(message: string, title?: string, config?: Partial<RcToastConfig>): RcToastRef;
+    private _add;
+    /**
+     * Lazily create (or reuse) a CDK overlay pane + container component
+     * for a given position.
+     */
+    private _ensureContainer;
+    private _buildPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RcToastService>;
+}
+/**
+ * Individual toast notification UI.
+ *
+ * Rendered inside `RcToastContainerComponent`; not intended for direct use.
+ */
+declare class RcToastComponent {
+    toast: RcToastRef;
+    close: EventEmitter<string>;
+    get toastClasses(): string;
+    get statusIcon(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcToastComponent, "rc-toast", never, { "toast": { "alias": "toast"; "required": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+/**
+ * Host container for a group of toasts at a given screen position.
+ *
+ * Created dynamically by `RcToastService` via CDK Overlay.
+ * One container instance is created per position.
+ *
+ * The service owns the toasts list; it updates the `toasts` signal and
+ * listens to the `close` output.
+ */
+declare class RcToastContainerComponent {
+    position: RcToastPosition;
+    /** Signal-backed list — the service calls .set() to push updates. */
+    readonly toasts: i0.WritableSignal<RcToastRef[]>;
+    /** Emits the id of the toast the user wants to dismiss. */
+    close: EventEmitter<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcToastContainerComponent, "rc-toast-container", never, { "position": { "alias": "position"; "required": false; }; }, { "close": "close"; }, never, never, true, never>;
+}
+type RcInputStatus = 'default' | 'success' | 'danger' | 'warning';
+type RcInputSize = 'sm' | 'md' | 'lg';
+/**
+ * Attribute directive that styles native `<input>` and `<textarea>` elements
+ * with Resolve design tokens.
+ *
+ * Apply `rcInput` to any `<input>` or `<textarea>` element. The element
+ * receives the full input styling, size modifiers, and validation state classes.
+ *
+ * Labels, hints, and error messages are provided by the consumer using the
+ * optional `.rc-field`, `.rc-field-label`, `.rc-field-hint`, and
+ * `.rc-field-error` CSS helper classes (included in the global stylesheet).
+ *
+ * @example Basic
+ * ```html
+ * <input rcInput placeholder="Search…" />
+ * ```
+ *
+ * @example With label and hint wrapper
+ * ```html
+ * <div class="rc-field">
+ *   <label class="rc-field-label" for="email">Email</label>
+ *   <input rcInput id="email" type="email" placeholder="you@company.com" />
+ *   <span class="rc-field-hint">We&#39;ll never share your email.</span>
+ * </div>
+ * ```
+ *
+ * @example Validation state
+ * ```html
+ * <div class="rc-field">
+ *   <label class="rc-field-label">Password</label>
+ *   <input rcInput type="password" status="danger" />
+ *   <span class="rc-field-error">Must be at least 8 characters.</span>
+ * </div>
+ * ```
+ *
+ * @example Textarea
+ * ```html
+ * <textarea rcInput rows="4" placeholder="Your message…"></textarea>
+ * ```
+ *
+ * @example Sizes
+ * ```html
+ * <input rcInput size="sm" placeholder="Small" />
+ * <input rcInput size="md" placeholder="Medium" />
+ * <input rcInput size="lg" placeholder="Large" />
+ * ```
+ */
+declare class RcInputDirective {
+    private readonly _el;
+    /** @internal true when the directive is applied to a `<textarea>` */
+    readonly _isTextarea: boolean;
+    /** Validation / visual status of the field. */
+    status: RcInputStatus;
+    /** Size of the input field. */
+    size: RcInputSize;
+    /** @internal focus tracking for the focus ring class */
+    _focused: boolean;
+    _onFocus(): void;
+    _onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcInputDirective, "input[rcInput], textarea[rcInput]", never, { "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Configuration for opening an RcDialog.
+ *
+ * @example
+ * ```typescript
+ * this.dialog.open(MyDialogComponent, {
+ *   data: { id: 42 },
+ *   width: '32rem',
+ *   disableClose: false,
+ * });
+ * ```
+ */
+interface RcDialogConfig<D = unknown> {
+    /** Data injected into the dialog content component via `RC_DIALOG_DATA`. */
+    data?: D;
+    /** Fixed width of the dialog panel (e.g. `'32rem'`, `'600px'`). */
+    width?: string;
+    /** Max width. Defaults to `'90vw'`. */
+    maxWidth?: string;
+    /** Min width of the dialog panel. */
+    minWidth?: string;
+    /** Fixed height of the dialog panel. */
+    height?: string;
+    /** When `true`, clicking the backdrop or pressing Escape will NOT close the dialog. Default: `false`. */
+    disableClose?: boolean;
+    /** Extra CSS class(es) applied to the CDK overlay pane. */
+    panelClass?: string | string[];
+    /** ARIA label for the dialog panel. */
+    ariaLabel?: string;
+    /** ARIA label for the close button. Default: `'Close dialog'` */
+    closeAriaLabel?: string;
+    /** ID of the element describing the dialog (sets `aria-describedby`). */
+    ariaDescribedBy?: string;
+}
+/**
+ * Injection token for the data passed to a dialog content component.
+ *
+ * @example
+ * ```typescript
+ * export class MyDialogComponent {
+ *   readonly data = inject<MyData>(RC_DIALOG_DATA);
+ * }
+ * ```
+ */
+declare const RC_DIALOG_DATA: InjectionToken<unknown>;
+/**
+ * Reference to an open dialog, returned by `RcDialogService.open()`.
+ *
+ * Inject it inside the dialog content component to close it programmatically
+ * or subscribe to its close event.
+ *
+ * @example
+ * ```typescript
+ * export class ConfirmDialogComponent {
+ *   private readonly dialogRef = inject<RcDialogRef<boolean>>(RcDialogRef);
+ *
+ *   confirm(): void { this.dialogRef.close(true); }
+ *   cancel(): void  { this.dialogRef.close(false); }
+ * }
+ * ```
+ */
+declare class RcDialogRef<R = unknown, D = unknown> {
+    private readonly _overlayRef;
+    /** The config used to open this dialog. */
+    readonly config: RcDialogConfig<D>;
+    private readonly _afterClosed;
+    /**
+     * Emits once (with the optional result value) when the dialog fully closes,
+     * then completes.
+     */
+    readonly afterClosed: Observable<R | undefined>;
+    private _closed;
+    constructor(_overlayRef: OverlayRef,
+    /** The config used to open this dialog. */
+    config: RcDialogConfig<D>);
+    /**
+     * Closes the dialog, passing an optional result value to `afterClosed`
+     * subscribers.
+     */
+    close(result?: R): void;
+    /** Observable of backdrop click events. */
+    get backdropClick$(): Observable<MouseEvent>;
+}
+/**
+ * Service for opening modal dialogs built on top of Angular CDK Overlay.
+ *
+ * The dialog renders a floating panel with a backdrop, centered on screen.
+ * Pass any component as the first argument; it becomes the dialog's content.
+ *
+ * ## Setup
+ * The service is `providedIn: 'root'`. No extra setup is required.
+ *
+ * ## Usage
+ * ```typescript
+ * export class MyPage {
+ *   private dialog = inject(RcDialogService);
+ *
+ *   openConfirm(): void {
+ *     const ref = this.dialog.open<boolean, { name: string }>(ConfirmDialogComponent, {
+ *       data: { name: 'record #42' },
+ *       width: '28rem',
+ *     });
+ *
+ *     ref.afterClosed.subscribe(result => {
+ *       if (result) this.deleteRecord();
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * ## Dialog content component
+ * The content component can inject `RcDialogRef` to close the dialog and
+ * `RC_DIALOG_DATA` to access passed data:
+ *
+ * ```typescript
+ * export class ConfirmDialogComponent {
+ *   readonly data   = inject<{ name: string }>(RC_DIALOG_DATA);
+ *   readonly dialog = inject<RcDialogRef<boolean>>(RcDialogRef);
+ * }
+ * ```
+ *
+ * Use `rcDialogTitle`, `rcDialogContent`, and `rcDialogActions` directives to
+ * structure the dialog's layout:
+ *
+ * ```html
+ * <h2 rcDialogTitle>Confirm deletion</h2>
+ * <div rcDialogContent>
+ *   <p>Delete {{ data.name }}? This action cannot be undone.</p>
+ * </div>
+ * <div rcDialogActions>
+ *   <button rcButton variant="ghost"   (click)="dialog.close(false)">Cancel</button>
+ *   <button rcButton status="danger"  (click)="dialog.close(true)">Delete</button>
+ * </div>
+ * ```
+ */
+declare class RcDialogService {
+    private readonly _overlay;
+    private readonly _injector;
+    /**
+     * Opens a dialog containing the given component.
+     *
+     * @param component  The Angular component class to render as dialog content.
+     * @param config     Optional dialog configuration.
+     * @returns          An `RcDialogRef` to control and observe the opened dialog.
+     */
+    open<R = unknown, D = unknown>(component: Type<unknown>, config?: RcDialogConfig<D>): RcDialogRef<R, D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RcDialogService>;
+}
+/**
+ * Marks a heading element as the dialog title.
+ * Provides consistent font size, weight, and padding (accounting for the
+ * close button).
+ *
+ * @example
+ * ```html
+ * <h2 rcDialogTitle>Confirm deletion</h2>
+ * ```
+ */
+declare class RcDialogTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDialogTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcDialogTitleDirective, "[rcDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marks the main scrollable content area of a dialog.
+ * Apply to a wrapper `<div>` or `<section>` inside the content component.
+ *
+ * @example
+ * ```html
+ * <div rcDialogContent>
+ *   <p>Are you sure you want to delete this record?</p>
+ * </div>
+ * ```
+ */
+declare class RcDialogContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDialogContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcDialogContentDirective, "[rcDialogContent]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marks the footer area of a dialog, typically containing action buttons.
+ * Buttons are right-aligned by default; add `align="start"` to left-align.
+ *
+ * @example
+ * ```html
+ * <div rcDialogActions>
+ *   <button rcButton variant="ghost" (click)="dialogRef.close()">Cancel</button>
+ *   <button rcButton status="primary" (click)="confirm()">Confirm</button>
+ * </div>
+ * ```
+ */
+declare class RcDialogActionsDirective {
+    /** Alignment of the action buttons. Default: `'end'` */
+    align: 'start' | 'end';
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDialogActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcDialogActionsDirective, "[rcDialogActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Internal overlay container for `RcDialogService`.
+ *
+ * Do not use directly — open dialogs via `RcDialogService.open()`.
+ */
+declare class RcDialogContainerComponent {
+    private readonly _outlet;
+    readonly _dialogRef: RcDialogRef<any, any>;
+    get _config(): _resolve_components_theme.RcDialogConfig<any>;
+    /** Attach the user's content component into the portal outlet. */
+    attachContent<C>(portal: ComponentPortal<C>): ComponentRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDialogContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcDialogContainerComponent, "rc-dialog-container", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Header-cell definition structural directive.
+ * Use as `*rcHeaderCellDef` inside an `[rcColumnDef]` template.
+ *
+ * @example
+ * ```html
+ * <ng-container rcColumnDef="name">
+ *   <th rcHeaderCell *rcHeaderCellDef>Name</th>
+ *   <td rcCell *rcCellDef="let row">{{ row.name }}</td>
+ * </ng-container>
+ * ```
+ */
+declare class RcHeaderCellDefDirective extends CdkHeaderCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcHeaderCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcHeaderCellDefDirective, "[rcHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+/** Data-cell definition structural directive. Use as `*rcCellDef="let row"`. */
+declare class RcCellDefDirective extends CdkCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcCellDefDirective, "[rcCellDef]", never, {}, {}, never, never, true, never>;
+}
+/** Footer-cell definition structural directive. Use as `*rcFooterCellDef`. */
+declare class RcFooterCellDefDirective extends CdkFooterCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcFooterCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcFooterCellDefDirective, "[rcFooterCellDef]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Column definition — wraps all templates for a single column.
+ *
+ * @example
+ * ```html
+ * <ng-container [rcColumnDef]="'status'">
+ *   <th rcHeaderCell *rcHeaderCellDef>Status</th>
+ *   <td rcCell *rcCellDef="let row">{{ row.status }}</td>
+ * </ng-container>
+ * ```
+ */
+declare class RcColumnDefDirective extends CdkColumnDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcColumnDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcColumnDefDirective, "[rcColumnDef]", never, { "name": { "alias": "rcColumnDef"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Header-cell host directive — apply to `<th>` inside `*rcHeaderCellDef` templates.
+ *
+ * @example
+ * ```html
+ * <th rcHeaderCell *rcHeaderCellDef>Column title</th>
+ * ```
+ */
+declare class RcHeaderCellDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcHeaderCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcHeaderCellDirective, "rc-header-cell, th[rcHeaderCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Data-cell host directive — apply to `<td>` inside `*rcCellDef` templates.
+ *
+ * @example
+ * ```html
+ * <td rcCell *rcCellDef="let row">{{ row.name }}</td>
+ * ```
+ */
+declare class RcCellDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcCellDirective, "rc-cell, td[rcCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Footer-cell host directive — apply to `<td>` inside `*rcFooterCellDef` templates.
+ *
+ * @example
+ * ```html
+ * <td rcFooterCell *rcFooterCellDef>Total</td>
+ * ```
+ */
+declare class RcFooterCellDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcFooterCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcFooterCellDirective, "rc-footer-cell, td[rcFooterCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Header-row definition — declares the set of columns the header row should render.
+ *
+ * @example
+ * ```html
+ * <tr rc-header-row *rcHeaderRowDef="displayedColumns; sticky: true"></tr>
+ * ```
+ */
+declare class RcHeaderRowDefDirective extends CdkHeaderRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcHeaderRowDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcHeaderRowDefDirective, "[rcHeaderRowDef]", never, { "columns": { "alias": "rcHeaderRowDef"; "required": false; }; "sticky": { "alias": "rcHeaderRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Data-row definition — declares the columns and an optional predicate to
+ * decide which rows use this definition.
+ *
+ * @example
+ * ```html
+ * <tr rc-row *rcRowDef="let row; columns: displayedColumns"></tr>
+ * ```
+ */
+declare class RcRowDefDirective<T> extends CdkRowDef<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcRowDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcRowDefDirective<any>, "[rcRowDef]", never, { "columns": { "alias": "rcRowDefColumns"; "required": false; }; "when": { "alias": "rcRowDefWhen"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Footer-row definition — declares the columns the footer row should render.
+ *
+ * @example
+ * ```html
+ * <tr rc-footer-row *rcFooterRowDef="displayedColumns; sticky: true"></tr>
+ * ```
+ */
+declare class RcFooterRowDefDirective extends CdkFooterRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcFooterRowDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcFooterRowDefDirective, "[rcFooterRowDef]", never, { "columns": { "alias": "rcFooterRowDef"; "required": false; }; "sticky": { "alias": "rcFooterRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Header row component — rendered once for each `[rcHeaderRowDef]`. */
+declare class RcHeaderRowComponent extends CdkHeaderRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcHeaderRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcHeaderRowComponent, "rc-header-row, tr[rc-header-row]", never, {}, {}, never, never, true, never>;
+}
+/** Data row component — rendered once per data row. */
+declare class RcRowComponent extends CdkRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcRowComponent, "rc-row, tr[rc-row]", never, {}, {}, never, never, true, never>;
+}
+/** Footer row component — rendered once for each `[rcFooterRowDef]`. */
+declare class RcFooterRowComponent extends CdkFooterRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcFooterRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcFooterRowComponent, "rc-footer-row, tr[rc-footer-row]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * No-data row — shown when the data source has no rows.
+ *
+ * @example
+ * ```html
+ * <ng-template rcNoDataRow>
+ *   <tr><td [attr.colspan]="columns.length">No results found.</td></tr>
+ * </ng-template>
+ * ```
+ */
+declare class RcNoDataRowDirective extends CdkNoDataRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNoDataRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcNoDataRowDirective, "ng-template[rcNoDataRow]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A data table built on top of Angular CDK's `CdkTable`, styled with Resolve
+ * design tokens.
+ *
+ * Use `[rcColumnDef]`, `*rcHeaderCellDef`, `*rcCellDef`, `[rcHeaderRowDef]`,
+ * and `*rcRowDef` to declare the table structure.
+ *
+ * @example
+ * ```html
+ * <table rcTable [dataSource]="dataSource">
+ *   <ng-container [rcColumnDef]="'name'">
+ *     <th rcHeaderCell *rcHeaderCellDef>Name</th>
+ *     <td rcCell *rcCellDef="let row">{{ row.name }}</td>
+ *   </ng-container>
+ *
+ *   <tr rc-header-row *rcHeaderRowDef="displayedColumns"></tr>
+ *   <tr rc-row *rcRowDef="let row; columns: displayedColumns"></tr>
+ * </table>
+ * ```
+ */
+declare class RcTableComponent<T> extends CdkTable<T> {
+    /** @internal */
+    protected stickyCssClass: string;
+    /** @internal */
+    protected needsPositionStickyOnElement: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcTableComponent<any>, "rc-table, table[rcTable]", never, {}, {}, never, never, true, never>;
+}
+/** All RC Table directives and components — import this array in your module/component. */
+declare const RC_TABLE_DIRECTIVES: readonly [typeof RcTableComponent, typeof RcColumnDefDirective, typeof RcHeaderCellDefDirective, typeof RcCellDefDirective, typeof RcFooterCellDefDirective, typeof RcHeaderCellDirective, typeof RcCellDirective, typeof RcFooterCellDirective, typeof RcHeaderRowDefDirective, typeof RcRowDefDirective, typeof RcFooterRowDefDirective, typeof RcHeaderRowComponent, typeof RcRowComponent, typeof RcFooterRowComponent, typeof RcNoDataRowDirective];
+/** Sort direction. An empty string means "unsorted". */
+type RcSortDirection = 'asc' | 'desc' | '';
+/** State emitted by `RcSortDirective` when the active column or direction changes. */
+interface RcSortState {
+    /** Column id that is currently sorted. */
+    active: string;
+    /** Current sort direction. Empty string means no active sort. */
+    direction: RcSortDirection;
+}
+/** Injection token used by `RcSortHeaderComponent` to locate its parent sort directive. */
+declare const RC_SORT: InjectionToken<RcSortDirective>;
+/**
+ * Host directive that adds sorting state to an `rc-table` or `<table>`.
+ *
+ * Pair with `[rcSortHeader]` attributes on header cells. The directive tracks
+ * which column is active and in which direction, emitting `rcSortChange` on
+ * every transition.
+ *
+ * The cycling order is: _none_ → `asc` → `desc` → _none_.
+ *
+ * @example
+ * ```html
+ * <table rcTable [dataSource]="ds" rcSort (rcSortChange)="ds.sort = $event">
+ *   ...
+ * </table>
+ * ```
+ */
+declare class RcSortDirective {
+    /** The id of the currently active sort column, or `''` if unsorted. */
+    readonly active: i0.WritableSignal<string>;
+    /** The current sort direction. */
+    readonly direction: i0.WritableSignal<RcSortDirection>;
+    /** Emits whenever the active column or direction changes. */
+    readonly rcSortChange: EventEmitter<RcSortState>;
+    /** @internal Called by `RcSortHeaderComponent` when the user clicks a header. */
+    sort(columnId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcSortDirective, "[rcSort]", ["rcSort"], {}, { "rcSortChange": "rcSortChange"; }, never, never, true, never>;
+}
+/**
+ * Sort-header component — apply as an attribute to a `<th>` cell to make the
+ * column sortable. Requires a parent `[rcSort]` directive.
+ *
+ * Cycles direction on each click: _none_ → `asc` → `desc` → _none_.
+ *
+ * @example
+ * ```html
+ * <th rcHeaderCell *rcHeaderCellDef [rcSortHeader]="'name'">Name</th>
+ * ```
+ */
+declare class RcSortHeaderComponent {
+    /** The column id this header controls. Matches the `[rcColumnDef]` name. */
+    columnId: string;
+    /** @internal */
+    readonly _sort: RcSortDirective;
+    /** @internal */
+    readonly _isActive: i0.Signal<boolean>;
+    /** @internal */
+    readonly _ariaSort: i0.Signal<"ascending" | "descending" | null>;
+    /** @internal */
+    _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSortHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSortHeaderComponent, "[rcSortHeader]", never, { "columnId": { "alias": "rcSortHeader"; "required": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Client-side data source for `rc-table`.
+ *
+ * Handles in-memory sorting and filtering. For server-side data or pagination,
+ * implement `DataSource<T>` directly or extend this class.
+ *
+ * @example
+ * ```typescript
+ * interface User { id: number; name: string; email: string; role: string; }
+ *
+ * readonly dataSource = new RcTableDataSource<User>(USERS);
+ *
+ * // Filter:
+ * onFilter(value: string): void { this.dataSource.filter = value; }
+ *
+ * // Sort (bind via @ViewChild after view init):
+ * @ViewChild(RcSortDirective) sort!: RcSortDirective;
+ * ngAfterViewInit() { this.dataSource.sort = this.sort; }
+ * ```
+ */
+declare class RcTableDataSource<T> extends DataSource<T> {
+    private readonly _data$;
+    private readonly _filter$;
+    private readonly _sortChange$;
+    private _sort;
+    private _sortSubscription;
+    /** The raw data items rendered by the table. */
+    get data(): T[];
+    set data(value: T[]);
+    /**
+     * Filter string applied to every row.
+     * Setting this triggers a re-render; the string is trimmed and lower-cased
+     * before being passed to `filterPredicate`.
+     */
+    get filter(): string;
+    set filter(value: string);
+    /**
+     * The `RcSortDirective` instance connected to the table.
+     * When set, the data source subscribes to sort-change events and
+     * re-sorts on every header click.
+     */
+    get sort(): RcSortDirective | null;
+    set sort(value: RcSortDirective | null);
+    /**
+     * Returns the comparable value of `data[sortHeaderId]` used during sorting.
+     * Override to support nested paths or computed values.
+     */
+    sortingDataAccessor: (data: T, sortHeaderId: string) => string | number;
+    /**
+     * Returns `true` if `data` should be included for the active `filter` string.
+     * Default implementation joins all property values and does a substring check.
+     * Override to restrict which columns participate in filtering.
+     */
+    filterPredicate: (data: T, filter: string) => boolean;
+    constructor(initialData?: T[]);
+    connect(): Observable<T[]>;
+    disconnect(): void;
+}
+type RcChipStatus = 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+type RcChipSize = 'sm' | 'md';
+/**
+ * A compact interactive label — optionally clickable and/or closeable.
+ *
+ * Chips represent discrete values such as filters, tags, or selected options.
+ * They can be made clickable and/or include a close/remove button.
+ *
+ * @example Basic chip
+ * ```html
+ * <rc-chip>Design</rc-chip>
+ * ```
+ *
+ * @example Clickable chip with icon
+ * ```html
+ * <rc-chip status="primary" icon="star" (chipClick)="onSelect()">Favourite</rc-chip>
+ * ```
+ *
+ * @example Closeable chip (filter tag)
+ * ```html
+ * <rc-chip status="primary" [closeable]="true" (closed)="removeFilter('tag')">
+ *   Angular
+ * </rc-chip>
+ * ```
+ *
+ * @example Disabled chip
+ * ```html
+ * <rc-chip [disabled]="true">Not available</rc-chip>
+ * ```
+ *
+ * @input status    - Colour status. Default: `'default'`
+ * @input size      - Chip size. Default: `'md'`
+ * @input icon      - Eva Icons icon name shown before the label.
+ * @input closeable - Shows a close/remove button. Default: `false`
+ * @input disabled  - Disables all interactions. Default: `false`
+ * @input selected  - Renders the chip in its selected/active state. Default: `false`
+ * @output chipClick - Emits when the chip body is clicked (and not disabled).
+ * @output closed    - Emits when the close button is clicked (and not disabled).
+ */
+declare class RcChipComponent {
+    /** Colour status */
+    status: RcChipStatus;
+    /** Chip size */
+    size: RcChipSize;
+    /** Eva Icons icon name to show before the label */
+    icon: string;
+    /** Show a close/remove button */
+    closeable: boolean;
+    /** Disable all interactions */
+    disabled: boolean;
+    /** Render in selected/active state */
+    selected: boolean;
+    /** Emits when the chip body is clicked and not disabled */
+    chipClick: EventEmitter<MouseEvent>;
+    /** Emits when the close button is clicked and not disabled */
+    closed: EventEmitter<void>;
+    get hasClickListeners(): boolean;
+    onClick(event: MouseEvent): void;
+    onKeydown(event: Event): void;
+    onClose(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcChipComponent, "rc-chip", never, { "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "chipClick": "chipClick"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+type RcRadioSize = 'sm' | 'md';
+declare const RC_RADIO_GROUP: InjectionToken<RcRadioGroupComponent>;
+/**
+ * Container for a group of radio buttons. Supports `[(ngModel)]` and reactive forms.
+ *
+ * @example With ngModel
+ * ```html
+ * <rc-radio-group [(ngModel)]="selectedPlan">
+ *   <rc-radio-button value="free">Free</rc-radio-button>
+ *   <rc-radio-button value="pro">Pro</rc-radio-button>
+ *   <rc-radio-button value="enterprise">Enterprise</rc-radio-button>
+ * </rc-radio-group>
+ * ```
+ *
+ * @example Disabled group
+ * ```html
+ * <rc-radio-group [disabled]="true" [value]="'a'">
+ *   <rc-radio-button value="a">Option A</rc-radio-button>
+ *   <rc-radio-button value="b">Option B</rc-radio-button>
+ * </rc-radio-group>
+ * ```
+ *
+ * @input value    - Currently selected value.
+ * @input disabled - Disables all buttons in the group. Default: `false`
+ * @input size     - Size applied to all buttons. Default: `'md'`
+ * @output valueChange - Emits the new value when selection changes.
+ */
+declare class RcRadioGroupComponent implements ControlValueAccessor {
+    private readonly cdr;
+    /** Currently selected value */
+    get value(): unknown;
+    set value(v: unknown);
+    private _value;
+    /** Disables every radio button in the group */
+    disabled: boolean;
+    /** Size for all buttons in the group */
+    size: RcRadioSize;
+    /** Emits the newly selected value */
+    valueChange: EventEmitter<unknown>;
+    onChange: (value: unknown) => void;
+    onTouched: () => void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    /** Called by child RcRadioButtonComponent when a button is selected */
+    select(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcRadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcRadioGroupComponent, "rc-radio-group", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+/**
+ * A single radio button, always used inside `<rc-radio-group>`.
+ *
+ * @example
+ * ```html
+ * <rc-radio-button value="option-a">Option A</rc-radio-button>
+ * ```
+ *
+ * @input value    - The value this button represents (compared to the group value).
+ * @input disabled - Disables this specific button. Default: `false`
+ */
+declare class RcRadioButtonComponent implements OnInit, OnDestroy {
+    readonly group: RcRadioGroupComponent | null;
+    private readonly cdr;
+    private groupSub?;
+    /** The value this radio button represents */
+    value: unknown;
+    /** Disable this specific radio button */
+    disabled: boolean;
+    get isChecked(): boolean;
+    get isDisabled(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    onKeydown(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcRadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcRadioButtonComponent, "rc-radio-button", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+type RcToggleSize = 'sm' | 'md' | 'lg';
+/**
+ * A toggle switch for binary on/off state. Supports `[(ngModel)]` and reactive forms.
+ *
+ * @example Basic toggle
+ * ```html
+ * <rc-toggle [(ngModel)]="isEnabled">Enable notifications</rc-toggle>
+ * ```
+ *
+ * @example Pre-checked, labelled
+ * ```html
+ * <rc-toggle [checked]="true" (checkedChange)="onChange($event)">
+ *   Dark mode
+ * </rc-toggle>
+ * ```
+ *
+ * @example Small, disabled
+ * ```html
+ * <rc-toggle size="sm" [disabled]="true" [checked]="true">Auto-save</rc-toggle>
+ * ```
+ *
+ * @input checked       - Whether the toggle is on. Default: `false`
+ * @input disabled      - Disables interaction. Default: `false`
+ * @input size          - Toggle size: `'sm'` | `'md'` | `'lg'`. Default: `'md'`
+ * @input labelPosition - Position of the label text. Default: `'right'`
+ * @output checkedChange - Emits the new boolean state on user interaction.
+ */
+declare class RcToggleComponent implements ControlValueAccessor {
+    private readonly cdr;
+    /** Whether the toggle is in the on state */
+    checked: boolean;
+    /** Disable interaction */
+    disabled: boolean;
+    /** Toggle size */
+    size: RcToggleSize;
+    /** Position of the label slot */
+    labelPosition: 'left' | 'right';
+    /** Emits the new checked state when toggled */
+    checkedChange: EventEmitter<boolean>;
+    private onChange;
+    private onTouched;
+    toggle(): void;
+    onKeydown(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcToggleComponent, "rc-toggle", never, { "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*", "*"], true, never>;
+}
+/** Validation / visual status for a checkbox. */
+type RcCheckboxStatus = 'default' | 'success' | 'warning' | 'danger';
+/** Size variant for a checkbox. */
+type RcCheckboxSize = 'sm' | 'md' | 'lg';
+/**
+ * A styled checkbox supporting checked, unchecked, and indeterminate states.
+ * Pairs with the `.rc-field` helper classes and fully integrates with
+ * `[(ngModel)]` and Angular Reactive Forms.
+ *
+ * @example Basic
+ * ```html
+ * <rc-checkbox [(ngModel)]="accepted">Accept terms</rc-checkbox>
+ * ```
+ *
+ * @example Indeterminate (e.g. "select all" row)
+ * ```html
+ * <rc-checkbox [checked]="someSelected" [indeterminate]="!allSelected"
+ *              (checkedChange)="toggleAll($event)">
+ *   Select all
+ * </rc-checkbox>
+ * ```
+ *
+ * @example Status variants
+ * ```html
+ * <rc-checkbox status="danger" [(ngModel)]="consented">
+ *   You must accept the terms
+ * </rc-checkbox>
+ * ```
+ *
+ * @example Sizes
+ * ```html
+ * <rc-checkbox size="sm">Small</rc-checkbox>
+ * <rc-checkbox size="md">Medium</rc-checkbox>
+ * <rc-checkbox size="lg">Large</rc-checkbox>
+ * ```
+ *
+ * @example Disabled
+ * ```html
+ * <rc-checkbox [disabled]="true" [checked]="true">Read-only option</rc-checkbox>
+ * ```
+ *
+ * @example No label (icon-only)
+ * ```html
+ * <rc-checkbox [(ngModel)]="row.selected" aria-label="Select row"></rc-checkbox>
+ * ```
+ */
+declare class RcCheckboxComponent implements ControlValueAccessor {
+    private readonly _cdr;
+    _nativeInput: ElementRef<HTMLInputElement>;
+    /** Whether the checkbox is checked. */
+    checked: boolean;
+    /**
+     * Puts the checkbox into an indeterminate (partially-selected) state.
+     * Ignored when `checked` is `true`.
+     */
+    indeterminate: boolean;
+    /** Disables interaction. */
+    disabled: boolean;
+    /** Validation / visual status applied to the box border / fill. */
+    status: RcCheckboxStatus;
+    /** Controls the bounding box and font size. */
+    size: RcCheckboxSize;
+    /** Position of the label slot relative to the checkbox box. */
+    labelPosition: 'left' | 'right';
+    /**
+     * Forwarded to the hidden native `<input>` as `aria-label`.
+     * Use when there is no visible label text (e.g. a "select row" checkbox).
+     */
+    ariaLabel: string;
+    /** Emits the new `checked` boolean when the user toggles the checkbox. */
+    readonly checkedChange: EventEmitter<boolean>;
+    _onTouched: () => void;
+    private _onChange;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal Called when the hidden native input changes. */
+    _onNativeChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcCheckboxComponent, "rc-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*", "*"], true, never>;
+}
+/** Validation / visual status for a select field. */
+type RcSelectStatus = 'default' | 'success' | 'warning' | 'danger';
+/** Size variant for a select trigger. */
+type RcSelectSize = 'sm' | 'md' | 'lg';
+/**
+ * A single selectable option for `<rc-select>`.
+ *
+ * Declare it as a child of `<rc-select>`. The text content is used as the
+ * display label unless an explicit `label` input is provided.
+ *
+ * @example Basic option
+ * ```html
+ * <rc-option value="us">United States</rc-option>
+ * ```
+ *
+ * @example Disabled option
+ * ```html
+ * <rc-option value="legacy" [disabled]="true">Legacy (unavailable)</rc-option>
+ * ```
+ */
+declare class RcOptionComponent {
+    /** The value this option represents. */
+    value: unknown;
+    /** Explicit display label. When omitted, the element's text content is used. */
+    label: string;
+    /** Disables this individual option so it cannot be selected. */
+    disabled: boolean;
+    private readonly _el;
+    /** @internal Resolved display label, used by the parent panel template. */
+    get _displayLabel(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcOptionComponent, "rc-option", never, { "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * A styled dropdown select that supports both single and multi-select modes.
+ * Built on Angular CDK Overlay for reliable positioning. Fully integrates with
+ * `[(ngModel)]` and Angular Reactive Forms via `ControlValueAccessor`.
+ *
+ * Declare `<rc-option>` elements as direct children to populate the dropdown.
+ *
+ * @example Single select with ngModel
+ * ```html
+ * <rc-select placeholder="Choose a role" [(ngModel)]="role">
+ *   <rc-option value="admin">Admin</rc-option>
+ *   <rc-option value="editor">Editor</rc-option>
+ *   <rc-option value="viewer">Viewer</rc-option>
+ * </rc-select>
+ * ```
+ *
+ * @example Multi-select
+ * ```html
+ * <rc-select [multiple]="true" placeholder="Select frameworks" [(ngModel)]="frameworks">
+ *   <rc-option value="angular">Angular</rc-option>
+ *   <rc-option value="react">React</rc-option>
+ *   <rc-option value="vue">Vue</rc-option>
+ * </rc-select>
+ * ```
+ *
+ * @example Validation status
+ * ```html
+ * <rc-select status="danger" [(ngModel)]="country">
+ *   <rc-option value="us">United States</rc-option>
+ *   <rc-option value="gb">United Kingdom</rc-option>
+ * </rc-select>
+ * ```
+ *
+ * @example Disabled
+ * ```html
+ * <rc-select [disabled]="true" [ngModel]="'admin'">
+ *   <rc-option value="admin">Admin</rc-option>
+ * </rc-select>
+ * ```
+ *
+ * @example Inside rc-field with label and hint
+ * ```html
+ * <div class="rc-field">
+ *   <label class="rc-field-label">Country</label>
+ *   <rc-select placeholder="Pick a country" [(ngModel)]="country" status="success">
+ *     <rc-option value="us">United States</rc-option>
+ *     <rc-option value="ca">Canada</rc-option>
+ *   </rc-select>
+ *   <span class="rc-field-success-hint">Great choice!</span>
+ * </div>
+ * ```
+ */
+declare class RcSelectComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {
+    /** Placeholder text shown when no value is selected. */
+    placeholder: string;
+    /** When `true`, multiple values can be selected (value is an array). */
+    multiple: boolean;
+    /** Disables the entire select control. */
+    disabled: boolean;
+    /** Validation / visual status of the field. */
+    status: RcSelectStatus;
+    /** Controls the height and font-size of the trigger. */
+    size: RcSelectSize;
+    /** Emits the selected value (or array of values) whenever the selection changes. */
+    readonly valueChange: EventEmitter<unknown>;
+    private readonly _panelTpl;
+    private readonly _optionList;
+    private readonly _overlay;
+    private readonly _vcr;
+    private readonly _el;
+    private readonly _cdr;
+    private _overlayRef;
+    private _portal;
+    /** @internal */
+    _open: boolean;
+    /** @internal */
+    _focused: boolean;
+    /** @internal Index of the keyboard-focused option in the open panel. */
+    _activeIndex: number;
+    private _value;
+    private _onChange;
+    private _onTouched;
+    /** @internal Flat array of current option instances. */
+    get _options(): RcOptionComponent[];
+    /** @internal Whether a non-empty value is currently set. */
+    get _hasValue(): boolean;
+    /** @internal Text to display in the trigger. */
+    get _displayValue(): string;
+    /** @internal Whether `value` is in the current selection. */
+    _isSelected(value: unknown): boolean;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** @internal */
+    _togglePanel(): void;
+    /** @internal */
+    _openPanel(): void;
+    /** @internal */
+    _closePanel(): void;
+    /** @internal Called when the user clicks an option in the panel. */
+    _onOptionClick(value: unknown, event: Event): void;
+    /** @internal Selects or toggles a value. */
+    _selectValue(value: unknown): void;
+    /** @internal */
+    _onKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    _onFocus(): void;
+    /** @internal */
+    _onBlur(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSelectComponent, "rc-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "valueChange": "valueChange"; }, ["_optionList"], ["*"], true, never>;
+}
+/** Injection token that provides the parent `RcAccordionComponent` to items. */
+declare const RC_ACCORDION: InjectionToken<RcAccordionComponent>;
+/** Visual style for the accordion. */
+type RcAccordionVariant = 'default' | 'filled';
+/**
+ * A single expandable panel inside an `<rc-accordion>`.
+ *
+ * @example
+ * ```html
+ * <rc-accordion>
+ *   <rc-accordion-item title="What is Resolve?">
+ *     Resolve is an Angular component library.
+ *   </rc-accordion-item>
+ * </rc-accordion>
+ * ```
+ */
+declare class RcAccordionItemComponent {
+    private readonly _accordion;
+    /** Header title of this panel. */
+    title: string;
+    /** Whether this panel starts expanded. */
+    set expanded(v: boolean);
+    /** Disables expanding / collapsing this panel. */
+    disabled: boolean;
+    /** Emits the new expanded state when the user opens or closes the panel. */
+    readonly expandedChange: EventEmitter<boolean>;
+    /** @internal */
+    readonly _expanded: i0.WritableSignal<boolean>;
+    /** @internal */
+    _toggle(): void;
+    /** @internal */
+    _setExpanded(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcAccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcAccordionItemComponent, "rc-accordion-item", never, { "title": { "alias": "title"; "required": true; }; "expanded": { "alias": "expanded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Container that groups `<rc-accordion-item>` panels.
+ * By default only one item is open at a time; set `multiple` to allow multiple.
+ *
+ * @example Basic
+ * ```html
+ * <rc-accordion>
+ *   <rc-accordion-item title="Section 1">Content 1</rc-accordion-item>
+ *   <rc-accordion-item title="Section 2">Content 2</rc-accordion-item>
+ * </rc-accordion>
+ * ```
+ *
+ * @example Allow multiple panels open
+ * ```html
+ * <rc-accordion [multiple]="true">...</rc-accordion>
+ * ```
+ *
+ * @example Filled variant
+ * ```html
+ * <rc-accordion variant="filled">...</rc-accordion>
+ * ```
+ */
+declare class RcAccordionComponent {
+    /** Allow multiple panels to be open simultaneously. Default: `false`. */
+    multiple: boolean;
+    /** Visual style variant. Default: `'default'`. */
+    variant: RcAccordionVariant;
+    private _items;
+    /** @internal Called by a child item when it wants to open. */
+    _open(item: RcAccordionItemComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcAccordionComponent, "rc-accordion", never, { "multiple": { "alias": "multiple"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, ["_items"], ["*"], true, never>;
+}
+/** Size variant for the slider track and thumb. */
+type RcSliderSize = 'sm' | 'md' | 'lg';
+/** Validation / visual status for the slider fill and thumb. */
+type RcSliderStatus = 'default' | 'success' | 'warning' | 'danger';
+/**
+ * A range slider for selecting a numeric value between `min` and `max`.
+ * Integrates with `[(ngModel)]` and Angular Reactive Forms via ControlValueAccessor.
+ *
+ * @example Basic
+ * ```html
+ * <rc-slider [(ngModel)]="volume" [min]="0" [max]="100"></rc-slider>
+ * ```
+ *
+ * @example With value label and unit
+ * ```html
+ * <rc-slider [(ngModel)]="opacity" [min]="0" [max]="1" [step]="0.01"
+ *            [showValue]="true" unit=""></rc-slider>
+ * ```
+ *
+ * @example With tick marks
+ * ```html
+ * <rc-slider [(ngModel)]="rating" [min]="1" [max]="5" [step]="1"
+ *            [showTicks]="true" [showValue]="true"></rc-slider>
+ * ```
+ *
+ * @example Disabled
+ * ```html
+ * <rc-slider [value]="50" [disabled]="true"></rc-slider>
+ * ```
+ */
+declare class RcSliderComponent implements ControlValueAccessor, OnChanges {
+    private readonly _cdr;
+    /** Current numeric value. */
+    value: number;
+    /** Minimum value. Default: `0`. */
+    min: number;
+    /** Maximum value. Default: `100`. */
+    max: number;
+    /** Step increment. Default: `1`. */
+    step: number;
+    /** Disables the slider. Default: `false`. */
+    disabled: boolean;
+    /** Size of the track and thumb. Default: `'md'`. */
+    size: RcSliderSize;
+    /** Show the current value and min/max labels. Default: `false`. */
+    showValue: boolean;
+    /** String appended to the value label (e.g. `'%'`, `' px'`). Default: `''`. */
+    unit: string;
+    /** Show tick marks at each `step` interval (for small ranges). Default: `false`. */
+    showTicks: boolean;
+    /** Validation / visual status applied to the fill and thumb. Default: `'default'`. */
+    status: RcSliderStatus;
+    /** Emits the new value when the user drags the thumb. */
+    readonly valueChange: EventEmitter<number>;
+    readonly _value: i0.WritableSignal<number>;
+    readonly _fillPercent: i0.Signal<number>;
+    readonly _ticks: i0.Signal<{
+        value: number;
+        percent: number;
+    }[]>;
+    ngOnChanges(): void;
+    _onTouched: () => void;
+    private _onChange;
+    writeValue(value: number): void;
+    registerOnChange(fn: (v: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal */
+    _onInput(event: Event): void;
+    private _clamp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSliderComponent, "rc-slider", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "showTicks": { "alias": "showTicks"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+/** Validation / visual status — mirrors `RcInputStatus`. */
+type RcAutocompleteStatus = RcInputStatus;
+/** Size variant — mirrors `RcInputSize`. */
+type RcAutocompleteSize = RcInputSize;
+/**
+ * A single suggestion in the autocomplete dropdown.
+ *
+ * Pass `value` / `label` objects **or** a plain `string[]` to the `options`
+ * input — strings are auto-converted so `value === label`.
+ */
+interface RcAutocompleteOption {
+    /** The opaque value emitted to the model when this option is selected. */
+    value: unknown;
+    /** Display label rendered in the dropdown and filled into the input. */
+    label: string;
+    /** When `true` this option cannot be selected. */
+    disabled?: boolean;
+}
+/**
+ * A text input that shows a filtered suggestion dropdown as the user types.
+ * Combines the `rcInput` styling with a CDK Overlay panel that is visually
+ * consistent with `<rc-select>`.
+ *
+ * Pass options via the `options` input. Built-in filtering can be replaced by
+ * setting `filterFn`.
+ *
+ * Implements `ControlValueAccessor` — works with `[(ngModel)]` and Reactive
+ * Forms. The bound value is the selected option's `value` (or the raw typed
+ * string when no matching option exists).
+ *
+ * @example Basic
+ * ```html
+ * <rc-autocomplete
+ *   placeholder="Search countries…"
+ *   [options]="countries"
+ *   [(ngModel)]="selectedCountry"
+ * ></rc-autocomplete>
+ * ```
+ *
+ * @example String array
+ * ```html
+ * <rc-autocomplete [options]="['Angular', 'React', 'Vue']"
+ *                 [(ngModel)]="framework"></rc-autocomplete>
+ * ```
+ *
+ * @example Validation status
+ * ```html
+ * <rc-autocomplete status="danger" [options]="cities"
+ *                 [(ngModel)]="city"></rc-autocomplete>
+ * ```
+ *
+ * @example Disabled
+ * ```html
+ * <rc-autocomplete [disabled]="true" [options]="items" [(ngModel)]="val"></rc-autocomplete>
+ * ```
+ *
+ * @example Custom filter
+ * ```html
+ * <rc-autocomplete [options]="opts" [filterFn]="myFilter" [(ngModel)]="val"></rc-autocomplete>
+ * ```
+ */
+declare class RcAutocompleteComponent implements ControlValueAccessor, OnChanges, OnDestroy {
+    private readonly _cdr;
+    private readonly _overlay;
+    private readonly _vcr;
+    private readonly _host;
+    private _inputEl;
+    private readonly _panelTpl;
+    /**
+     * Array of options shown in the suggestion dropdown.
+     * Accepts plain `string[]` (auto-converted) or `RcAutocompleteOption[]`.
+     */
+    set options(v: string[] | RcAutocompleteOption[]);
+    /** Placeholder text shown when the input is empty. */
+    placeholder: string;
+    /** Text shown in the dropdown when no options match the query. */
+    noResultsText: string;
+    /** ARIA label for the clear (×) button. */
+    clearAriaLabel: string;
+    /** Disables the control. */
+    disabled: boolean;
+    /** Validation / visual status applied to the input border and shadow. */
+    status: RcAutocompleteStatus;
+    /** Controls the height and font-size of the input. */
+    size: RcAutocompleteSize;
+    /**
+     * Custom filter predicate. Receives the current query and an option; return
+     * `true` to include the option in the dropdown.
+     *
+     * Defaults to a case-insensitive `includes` match on `option.label`.
+     */
+    filterFn: (query: string, option: RcAutocompleteOption) => boolean;
+    /**
+     * Emits the selected `RcAutocompleteOption` when the user picks a suggestion.
+     * Note: the `[(ngModel)]` / formControl value is the option's `value` field.
+     */
+    readonly selectionChange: EventEmitter<RcAutocompleteOption>;
+    /** @internal Text currently shown in the native input. */
+    readonly _inputText: i0.WritableSignal<string>;
+    /** @internal The opaque model value (option.value). */
+    readonly _modelValue: i0.WritableSignal<unknown>;
+    /** @internal All normalised options. */
+    readonly _allOptions: i0.WritableSignal<RcAutocompleteOption[]>;
+    /** @internal Filtered options based on current input text. */
+    readonly _filtered: i0.Signal<RcAutocompleteOption[]>;
+    /** @internal Whether the panel is currently open. */
+    _open: boolean;
+    /** @internal Keyboard-focused option index in the open panel. */
+    _activeIndex: number;
+    private _overlayRef;
+    private _portal;
+    private _onChange;
+    _onTouched: () => void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal */
+    _onInput(event: Event): void;
+    /** @internal */
+    _onFocus(): void;
+    /** @internal */
+    _onBlur(): void;
+    /** @internal */
+    _clear(): void;
+    /** @internal */
+    _selectOption(opt: RcAutocompleteOption): void;
+    /** @internal */
+    _onKeydown(event: KeyboardEvent): void;
+    private _openPanel;
+    /** @internal */
+    _closePanel(): void;
+    private _normalise;
+    private _setInputNative;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcAutocompleteComponent, "rc-autocomplete", never, { "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "noResultsText": { "alias": "noResultsText"; "required": false; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+/**
+ * Controls how the sidenav interacts with the main content.
+ *
+ * - `'over'`  — slides over the main content; a backdrop appears behind it.
+ * - `'push'`  — pushes the main content to the side; a backdrop appears.
+ * - `'side'`  — sits permanently adjacent to the main content; no backdrop.
+ */
+type RcSidenavMode = 'over' | 'push' | 'side';
+/** Which edge of the container the sidenav appears on. */
+type RcSidenavPosition = 'start' | 'end';
+/** @internal contract used for sidenav ↔ container communication */
+interface RcSidenavContainerRef {
+    _register(sidenav: RcSidenavComponent): void;
+    _deregister(sidenav: RcSidenavComponent): void;
+    _update(): void;
+}
+/** @internal injection token that provides the parent container to child sidenavs */
+declare const RC_SIDENAV_CONTAINER: InjectionToken<RcSidenavContainerRef>;
+/**
+ * Wraps the main content area inside an `<rc-sidenav-container>`.
+ *
+ * Using this wrapper is optional — any content not matched by
+ * `<rc-sidenav>` will fall into the default `<ng-content>` slot.
+ * However using this component enables correct scroll isolation.
+ *
+ * @example
+ * ```html
+ * <rc-sidenav-container>
+ *   <rc-sidenav>Navigation content</rc-sidenav>
+ *   <rc-sidenav-content>
+ *     <main>Page content</main>
+ *   </rc-sidenav-content>
+ * </rc-sidenav-container>
+ * ```
+ */
+declare class RcSidenavContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSidenavContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSidenavContentComponent, "rc-sidenav-content", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * A sliding side panel — the inner child of `<rc-sidenav-container>`.
+ *
+ * Place navigation links, filters, or any auxiliary content inside.
+ * Open and close programmatically via the `open()`, `close()` and `toggle()`
+ * methods, or bind `[(opened)]`.
+ *
+ * @example Over mode (default — panel slides over content)
+ * ```html
+ * <rc-sidenav-container>
+ *   <rc-sidenav #drawer>
+ *     <nav>Links here</nav>
+ *   </rc-sidenav>
+ *   <rc-sidenav-content>
+ *     <button (click)="drawer.toggle()">Menu</button>
+ *     <router-outlet></router-outlet>
+ *   </rc-sidenav-content>
+ * </rc-sidenav-container>
+ * ```
+ *
+ * @example Side mode (permanent)
+ * ```html
+ * <rc-sidenav-container style="height: 100vh">
+ *   <rc-sidenav mode="side" [opened]="true">
+ *     <nav>Sidebar</nav>
+ *   </rc-sidenav>
+ *   <rc-sidenav-content>Main content</rc-sidenav-content>
+ * </rc-sidenav-container>
+ * ```
+ *
+ * @example Push mode (panel pushes content aside)
+ * ```html
+ * <rc-sidenav-container>
+ *   <rc-sidenav #nav mode="push">Filters</rc-sidenav>
+ *   <rc-sidenav-content>
+ *     <button (click)="nav.toggle()">Toggle filters</button>
+ *   </rc-sidenav-content>
+ * </rc-sidenav-container>
+ * ```
+ *
+ * @example End position
+ * ```html
+ * <rc-sidenav position="end" mode="over">Details panel</rc-sidenav>
+ * ```
+ */
+declare class RcSidenavComponent implements OnInit, OnDestroy {
+    readonly _el: ElementRef<any>;
+    private readonly _cdr;
+    private readonly _container;
+    /**
+     * Interaction mode:
+     * - `'over'` (default) — panel floats above content; backdrop shown.
+     * - `'push'` — panel pushes the content; backdrop shown.
+     * - `'side'` — panel sits beside the content; no backdrop.
+     */
+    mode: RcSidenavMode;
+    /** Which edge to attach to. Default: `'start'` (left in LTR). */
+    position: RcSidenavPosition;
+    /**
+     * Whether clicking the backdrop or pressing Escape closes the sidenav.
+     * Only applies in `'over'` and `'push'` modes.
+     */
+    disableClose: boolean;
+    /** Programmatic open / close. Supports two-way binding: `[(opened)]`. */
+    set opened(v: boolean);
+    /** Emits `true` when the panel opens; `false` when it closes. */
+    readonly openedChange: EventEmitter<boolean>;
+    /** Emits when the open animation starts. */
+    readonly openedStart: EventEmitter<void>;
+    /** Emits when the close animation starts. */
+    readonly closedStart: EventEmitter<void>;
+    /** @internal */
+    readonly _isOpen: i0.WritableSignal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Opens the sidenav. Returns a promise that resolves after the animation. */
+    open(): Promise<void>;
+    /** Closes the sidenav. Returns a promise that resolves after the animation. */
+    close(): Promise<void>;
+    /** Toggles the sidenav open / closed. */
+    toggle(): void;
+    private _setOpened;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSidenavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSidenavComponent, "rc-sidenav", never, { "mode": { "alias": "mode"; "required": false; }; "position": { "alias": "position"; "required": false; }; "disableClose": { "alias": "disableClose"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; }, { "openedChange": "openedChange"; "openedStart": "openedStart"; "closedStart": "closedStart"; }, never, ["*"], true, never>;
+}
+/**
+ * Root wrapper for the sidenav layout. Place exactly one
+ * `<rc-sidenav>` and one `<rc-sidenav-content>` (or implicit content) inside.
+ *
+ * The container handles the backdrop overlay in `'over'` and `'push'` modes,
+ * Escape-key dismissal, and the push-mode content offset.
+ *
+ * Set an explicit `height` or `min-height` on the container so the panel
+ * fills the available space.
+ *
+ * @example Full-height app shell
+ * ```html
+ * <rc-sidenav-container style="height: 100vh">
+ *   <rc-sidenav #nav>
+ *     <nav>…</nav>
+ *   </rc-sidenav>
+ *   <rc-sidenav-content>
+ *     <rc-navbar><button (click)="nav.toggle()">☰</button></rc-navbar>
+ *     <router-outlet></router-outlet>
+ *   </rc-sidenav-content>
+ * </rc-sidenav-container>
+ * ```
+ */
+declare class RcSidenavContainerComponent implements RcSidenavContainerRef, AfterContentInit, OnDestroy {
+    private readonly _cdr;
+    private readonly _hostEl;
+    private readonly _contentSidenavs;
+    private _sidenavs;
+    /** @internal Whether the translucent backdrop is shown. */
+    _backdropVisible: boolean;
+    /** @internal Called by each sidenav on init. */
+    _register(sidenav: RcSidenavComponent): void;
+    /** @internal Called by each sidenav on destroy. */
+    _deregister(sidenav: RcSidenavComponent): void;
+    /** @internal Recalculate derived state after any sidenav state change. */
+    _update(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** @internal */
+    _onBackdropClick(): void;
+    /** @internal */
+    _onEscape(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSidenavContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSidenavContainerComponent, "rc-sidenav-container", never, {}, {}, ["_contentSidenavs"], ["rc-sidenav", "rc-sidenav-content", "*"], true, never>;
+}
+/** Colour variant for the navbar. */
+type RcNavbarColor = 'default' | 'primary';
+/** CSS position strategy. */
+type RcNavbarPosition = 'static' | 'sticky' | 'fixed';
+/**
+ * Marks the brand / logo area at the start of the navbar.
+ *
+ * Apply to a `<div>`, `<a>`, or any wrapper element.
+ *
+ * @example
+ * ```html
+ * <rc-navbar>
+ *   <a rcNavbarBrand routerLink="/">MyApp</a>
+ * </rc-navbar>
+ * ```
+ */
+declare class RcNavbarBrandDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNavbarBrandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcNavbarBrandDirective, "[rcNavbarBrand]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marks the trailing actions area at the end of the navbar.
+ *
+ * @example
+ * ```html
+ * <rc-navbar>
+ *   <div rcNavbarActions>
+ *     <button rcButton variant="ghost" [iconOnly]="true">
+ *       <rc-icon name="bell"></rc-icon>
+ *     </button>
+ *   </div>
+ * </rc-navbar>
+ * ```
+ */
+declare class RcNavbarActionsDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNavbarActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcNavbarActionsDirective, "[rcNavbarActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A flexible spacer that expands to fill remaining horizontal space,
+ * pushing subsequent elements to the end of the navbar.
+ *
+ * @example
+ * ```html
+ * <rc-navbar>
+ *   <a rcNavbarBrand routerLink="/">Logo</a>
+ *   <rc-navbar-spacer></rc-navbar-spacer>
+ *   <div rcNavbarActions>...</div>
+ * </rc-navbar>
+ * ```
+ */
+declare class RcNavbarSpacerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNavbarSpacerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcNavbarSpacerComponent, "rc-navbar-spacer", never, {}, {}, never, never, true, never>;
+}
+/**
+ * An individual row inside an `<rc-navbar>` — use when you need a
+ * multi-row navigation bar.
+ *
+ * @example
+ * ```html
+ * <rc-navbar>
+ *   <rc-navbar-row>
+ *     <a rcNavbarBrand routerLink="/">Logo</a>
+ *     <rc-navbar-spacer></rc-navbar-spacer>
+ *     <div rcNavbarActions>…actions…</div>
+ *   </rc-navbar-row>
+ *   <rc-navbar-row>
+ *     <!-- breadcrumbs or sub-navigation -->
+ *   </rc-navbar-row>
+ * </rc-navbar>
+ * ```
+ */
+declare class RcNavbarRowComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNavbarRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcNavbarRowComponent, "rc-navbar-row", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Top application bar — a horizontal strip for branding, navigation actions,
+ * and utility controls.
+ *
+ * Place `[rcNavbarBrand]`, `[rcNavbarActions]`, `<rc-navbar-spacer>`, and
+ * `<rc-navbar-row>` children inside to build up the bar.
+ *
+ * @example Minimal
+ * ```html
+ * <rc-navbar>
+ *   <a rcNavbarBrand routerLink="/">My App</a>
+ *   <rc-navbar-spacer></rc-navbar-spacer>
+ *   <div rcNavbarActions>
+ *     <button rcButton variant="ghost">Sign out</button>
+ *   </div>
+ * </rc-navbar>
+ * ```
+ *
+ * @example Primary colour + sticky
+ * ```html
+ * <rc-navbar color="primary" position="sticky">…</rc-navbar>
+ * ```
+ *
+ * @example With sidebar toggle
+ * ```html
+ * <rc-navbar>
+ *   <button rcButton variant="ghost" [iconOnly]="true" (click)="nav.toggle()">
+ *     <rc-icon name="menu"></rc-icon>
+ *   </button>
+ *   <a rcNavbarBrand routerLink="/">App</a>
+ *   <rc-navbar-spacer></rc-navbar-spacer>
+ *   <div rcNavbarActions>
+ *     <button rcButton variant="ghost" [iconOnly]="true">
+ *       <rc-icon name="person"></rc-icon>
+ *     </button>
+ *   </div>
+ * </rc-navbar>
+ * ```
+ *
+ * @example Multi-row
+ * ```html
+ * <rc-navbar>
+ *   <rc-navbar-row>
+ *     <a rcNavbarBrand>App</a>
+ *     <rc-navbar-spacer></rc-navbar-spacer>
+ *     <div rcNavbarActions>…</div>
+ *   </rc-navbar-row>
+ *   <rc-navbar-row>Sub-navigation or breadcrumbs</rc-navbar-row>
+ * </rc-navbar>
+ * ```
+ */
+declare class RcNavbarComponent {
+    /**
+     * Colour variant.
+     * - `'default'` — white / surface background (default)
+     * - `'primary'` — primary brand colour
+     */
+    color: RcNavbarColor;
+    /**
+     * CSS position strategy.
+     * - `'static'` — normal document flow (default).
+     * - `'sticky'` — stays at the top while scrolling.
+     * - `'fixed'` — fixed to the viewport; adds top padding to the container.
+     */
+    position: RcNavbarPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcNavbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcNavbarComponent, "rc-navbar", never, { "color": { "alias": "color"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** Validation / visual status. */
+type RcDatepickerStatus = 'default' | 'success' | 'warning' | 'danger';
+/** Size variant — matches `RcInputSize`. */
+type RcDatepickerSize = 'sm' | 'md' | 'lg';
+/**
+ * What the picker selects.
+ * - `'date'` — calendar only; model value has time zeroed.
+ * - `'time'` — clock only; only HH:MM are meaningful on the model value.
+ * - `'datetime'` — calendar + clock.
+ */
+type RcDatepickerMode = 'date' | 'time' | 'datetime';
+interface _CalendarDay {
+    date: Date;
+    day: number;
+    currentMonth: boolean;
+    today: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+/**
+ * A fully-themed date / time / datetime picker backed by CDK Overlay.
+ *
+ * The model value is always `Date | null`. Implements `ControlValueAccessor`
+ * for use with `[(ngModel)]` or Reactive Forms.
+ *
+ * @example Date picker (default)
+ * ```html
+ * <rc-datepicker [(ngModel)]="birthday" placeholder="Select date"></rc-datepicker>
+ * ```
+ *
+ * @example Time picker
+ * ```html
+ * <rc-datepicker mode="time" [(ngModel)]="meetingTime"></rc-datepicker>
+ * ```
+ *
+ * @example Date + time
+ * ```html
+ * <rc-datepicker mode="datetime" [(ngModel)]="appointment"></rc-datepicker>
+ * ```
+ *
+ * @example Validation status
+ * ```html
+ * <rc-datepicker status="danger" [(ngModel)]="dob"
+ *   placeholder="Date of birth"></rc-datepicker>
+ * ```
+ *
+ * @example Min / max
+ * ```html
+ * <rc-datepicker [min]="minDate" [max]="maxDate" [(ngModel)]="d"></rc-datepicker>
+ * ```
+ */
+declare class RcDatepickerComponent implements ControlValueAccessor, OnDestroy {
+    private readonly _cdr;
+    private readonly _overlay;
+    private readonly _vcr;
+    private readonly _host;
+    private _triggerEl;
+    private readonly _panelTpl;
+    /** Names of the 12 months, used as calendar header. Override to localise. */
+    monthNames: string[];
+    /** Two-letter weekday abbreviations shown in the day grid header. Override to localise. */
+    dayAbbrs: string[];
+    /** What the picker selects: `'date'` | `'time'` | `'datetime'`. Default: `'date'`. */
+    mode: RcDatepickerMode;
+    /** Placeholder shown when no value is selected. */
+    placeholder: string;
+    /** Validation / visual status. */
+    status: RcDatepickerStatus;
+    /** Size variant. */
+    size: RcDatepickerSize;
+    /** Disables the picker. */
+    disabled: boolean;
+    /**
+     * Minimum selectable date (inclusive).
+     * Dates before this are rendered disabled.
+     */
+    min: Date | null;
+    /**
+     * Maximum selectable date (inclusive).
+     * Dates after this are rendered disabled.
+     */
+    max: Date | null;
+    /** ARIA label for the clear (×) button in the trigger. */
+    clearAriaLabel: string;
+    /** ARIA label for the ‹ Previous month button. */
+    previousMonthAriaLabel: string;
+    /** ARIA label for the › Next month button. */
+    nextMonthAriaLabel: string;
+    /** ARIA label for the ▲ Increase-hour button. */
+    increaseHourAriaLabel: string;
+    /** ARIA label for the ▼ Decrease-hour button. */
+    decreaseHourAriaLabel: string;
+    /** ARIA label for the ▲ Increase-minute button. */
+    increaseMinuteAriaLabel: string;
+    /** ARIA label for the ▼ Decrease-minute button. */
+    decreaseMinuteAriaLabel: string;
+    /** Footer button label used in `date` mode. */
+    todayLabel: string;
+    /** Footer button label used in `time` and `datetime` modes. */
+    nowLabel: string;
+    /** Footer clear-value button label. */
+    clearLabel: string;
+    /** Footer apply button label (shown in `time` and `datetime` modes). */
+    applyLabel: string;
+    /** Emits the selected `Date` (or `null` after clearing). */
+    readonly dateChange: EventEmitter<Date | null>;
+    /** @internal Currently selected Date model value. */
+    readonly _value: i0.WritableSignal<Date | null>;
+    /** @internal Month index (0–11) of the calendar viewport. */
+    readonly _viewMonth: i0.WritableSignal<number>;
+    /** @internal Year of the calendar viewport. */
+    readonly _viewYear: i0.WritableSignal<number>;
+    /** @internal Which sub-view is active: 'days' | 'months' | 'years'. */
+    readonly _calView: i0.WritableSignal<"days" | "months" | "years">;
+    /** @internal Hours in the time picker (0–23). */
+    readonly _hours: i0.WritableSignal<number>;
+    /** @internal Minutes in the time picker (0–59). */
+    readonly _minutes: i0.WritableSignal<number>;
+    /** @internal Whether the overlay panel is open. */
+    _open: boolean;
+    private _overlayRef;
+    private _portal;
+    private _onChange;
+    _onTouched: () => void;
+    /** @internal Human-readable display text for the trigger. */
+    readonly _displayText: i0.Signal<string>;
+    /** @internal Current view month name. */
+    readonly _monthName: i0.Signal<string>;
+    /** @internal HH display. */
+    readonly _hoursDisplay: i0.Signal<string>;
+    /** @internal MM display. */
+    readonly _minutesDisplay: i0.Signal<string>;
+    /** @internal 20-year range around view year for the year grid. */
+    readonly _yearRange: i0.Signal<number[]>;
+    /** @internal Calendar day cells for the current view month/year. */
+    readonly _days: i0.Signal<_CalendarDay[]>;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (v: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal */
+    _togglePanel(): void;
+    private _openPanel;
+    /** @internal */
+    _closePanel(): void;
+    /** @internal */
+    _prevMonth(): void;
+    /** @internal */
+    _nextMonth(): void;
+    /** @internal */
+    _toggleCalView(): void;
+    /** @internal */
+    _selectMonth(month: number): void;
+    /** @internal */
+    _selectYear(year: number): void;
+    /** @internal */
+    _selectDay(date: Date): void;
+    /** @internal Apply the current time to the value and close (for mode=time or datetime). */
+    _applyTime(): void;
+    /** @internal */
+    _selectNow(): void;
+    /** @internal */
+    _clear(): void;
+    /** @internal */
+    _incHours(): void;
+    /** @internal */
+    _decHours(): void;
+    /** @internal */
+    _incMinutes(): void;
+    /** @internal */
+    _decMinutes(): void;
+    /** @internal */
+    _onHostKeydown(event: KeyboardEvent): void;
+    private _makeDay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcDatepickerComponent, "rc-datepicker", never, { "monthNames": { "alias": "monthNames"; "required": false; }; "dayAbbrs": { "alias": "dayAbbrs"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; }; "previousMonthAriaLabel": { "alias": "previousMonthAriaLabel"; "required": false; }; "nextMonthAriaLabel": { "alias": "nextMonthAriaLabel"; "required": false; }; "increaseHourAriaLabel": { "alias": "increaseHourAriaLabel"; "required": false; }; "decreaseHourAriaLabel": { "alias": "decreaseHourAriaLabel"; "required": false; }; "increaseMinuteAriaLabel": { "alias": "increaseMinuteAriaLabel"; "required": false; }; "decreaseMinuteAriaLabel": { "alias": "decreaseMinuteAriaLabel"; "required": false; }; "todayLabel": { "alias": "todayLabel"; "required": false; }; "nowLabel": { "alias": "nowLabel"; "required": false; }; "clearLabel": { "alias": "clearLabel"; "required": false; }; "applyLabel": { "alias": "applyLabel"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, true, never>;
+}
+/** A single node in the tree data model. */
+interface RcTreeNodeData {
+    /** Unique identifier for this node. */
+    id: string | number;
+    /** Display label. */
+    label: string;
+    /** Child nodes, if any. */
+    children?: RcTreeNodeData[];
+    /** Whether this node is disabled (cannot be selected or expanded). */
+    disabled?: boolean;
+}
+/** How the tree handles selection. */
+type RcTreeSelectionMode = 'single' | 'multiple' | 'none';
+/**
+ * @internal Renders a single tree node and its children recursively.
+ * Not part of the public API — use `rc-tree` with `[nodes]` instead.
+ */
+declare class RcTreeNodeComponent {
+    readonly _tree: RcTreeComponent;
+    /** @internal The node data for this row. */
+    node: RcTreeNodeData;
+    /** @internal Nesting level (0 = root). Used for indentation. */
+    level: number;
+    get hasChildren(): boolean;
+    readonly _expanded: i0.Signal<boolean>;
+    readonly _selected: i0.Signal<boolean>;
+    /** @internal */
+    _toggleExpand(): void;
+    /** @internal */
+    _onRowClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTreeNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcTreeNodeComponent, "rc-tree-node", never, { "node": { "alias": "node"; "required": true; }; "level": { "alias": "level"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * A hierarchical tree view that renders nested `RcTreeNodeData` items.
+ *
+ * Selection modes: `'single'` (default) | `'multiple'` | `'none'`.
+ *
+ * @example Basic tree
+ * ```html
+ * <rc-tree [nodes]="tree" [(selection)]="selected"></rc-tree>
+ * ```
+ *
+ * @example Multi-select
+ * ```html
+ * <rc-tree [nodes]="tree" selectionMode="multiple" [(selection)]="selected"></rc-tree>
+ * ```
+ *
+ * @example No selection (display only)
+ * ```html
+ * <rc-tree [nodes]="tree" selectionMode="none"></rc-tree>
+ * ```
+ *
+ * @example Pre-expanded nodes
+ * ```html
+ * <rc-tree [nodes]="tree" [expandedIds]="['folder-1']"></rc-tree>
+ * ```
+ */
+declare class RcTreeComponent implements OnChanges {
+    /** Tree data to render. */
+    nodes: RcTreeNodeData[];
+    /**
+     * How selection works.
+     * - `'single'` — only one node selected at a time (default).
+     * - `'multiple'` — any number of nodes may be selected.
+     * - `'none'` — nodes cannot be selected.
+     */
+    selectionMode: RcTreeSelectionMode;
+    /**
+     * IDs of nodes that should be selected.
+     * Use with `(selectionChange)` for two-way binding via `[(selection)]`.
+     */
+    selection: (string | number)[];
+    /**
+     * IDs of nodes that should start expanded.
+     * Changes after init are reflected reactively.
+     */
+    expandedIds: (string | number)[];
+    /** Emits the updated selection array whenever it changes. */
+    readonly selectionChange: EventEmitter<(string | number)[]>;
+    /** Emits the `RcTreeNodeData` of a node when it is clicked. */
+    readonly nodeClick: EventEmitter<RcTreeNodeData>;
+    /** Emits the `RcTreeNodeData` of a node when it expands. */
+    readonly nodeExpand: EventEmitter<RcTreeNodeData>;
+    /** Emits the `RcTreeNodeData` of a node when it collapses. */
+    readonly nodeCollapse: EventEmitter<RcTreeNodeData>;
+    /** @internal */
+    readonly _expandedIds: i0.WritableSignal<Set<string | number>>;
+    /** @internal */
+    readonly _selectedIds: i0.WritableSignal<Set<string | number>>;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @internal Called by node when user clicks it. */
+    _selectNode(node: RcTreeNodeData): void;
+    /** Expand all nodes in the tree. */
+    expandAll(): void;
+    /** Collapse all nodes in the tree. */
+    collapseAll(): void;
+    /** Clear all selections. */
+    clearSelection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcTreeComponent, "rc-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "expandedIds": { "alias": "expandedIds"; "required": false; }; }, { "selectionChange": "selectionChange"; "nodeClick": "nodeClick"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; }, never, never, true, never>;
+}
+/** Colour variant for the spinner circle. */
+type RcSpinnerStatus = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'basic';
+/** Size variant for the spinner. */
+type RcSpinnerSize = 'sm' | 'md' | 'lg';
+/**
+ * A spinning circle loader backed by Resolve design tokens.
+ *
+ * Can be used standalone as an inline or section-level loader, or placed on any
+ * host element via the `[rcSpinner]` directive which inserts it as an overlay.
+ *
+ * @example Inline usage
+ * ```html
+ * <rc-spinner></rc-spinner>
+ * <rc-spinner status="success" size="lg"></rc-spinner>
+ * <rc-spinner status="danger" message="Saving failed — retrying…"></rc-spinner>
+ * ```
+ *
+ * @example Status colours
+ * ```html
+ * <rc-spinner status="primary"></rc-spinner>
+ * <rc-spinner status="info"></rc-spinner>
+ * <rc-spinner status="success"></rc-spinner>
+ * <rc-spinner status="warning"></rc-spinner>
+ * <rc-spinner status="danger"></rc-spinner>
+ * <rc-spinner status="basic"></rc-spinner>
+ * ```
+ */
+declare class RcSpinnerComponent {
+    /** Colour status of the spinner circle. Default: `'primary'` */
+    status: RcSpinnerStatus;
+    /** Visual size of the spinner. Default: `'md'` */
+    size: RcSpinnerSize;
+    /** Optional label displayed below the spinner icon. */
+    message: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcSpinnerComponent, "rc-spinner", never, { "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive that overlays a spinner on any host element while `[rcSpinner]` is truthy.
+ *
+ * The host automatically receives `position: relative` (via the `rc-spinner-container`
+ * class) so the spinner is positioned relative to it.
+ *
+ * **Note:** avoid applying to void/self-closing elements (`<input>`, `<img>`, etc.).
+ * Wrap them in a `<div>` first.
+ *
+ * @example Overlay on a card
+ * ```html
+ * <rc-card [rcSpinner]="isLoading" rcSpinnerMessage="Fetching data…">
+ *   Content here
+ * </rc-card>
+ * ```
+ *
+ * @example Status and size
+ * ```html
+ * <div [rcSpinner]="saving" rcSpinnerStatus="success" rcSpinnerSize="lg">
+ *   <form>…</form>
+ * </div>
+ * ```
+ *
+ * @example Programmatic toggle
+ * ```html
+ * <div [rcSpinner]="loading" rcSpinnerMessage="Please wait…" style="padding:2rem">
+ *   <p>Content</p>
+ * </div>
+ * <button rcButton (click)="loading = !loading">Toggle spinner</button>
+ * ```
+ */
+declare class RcSpinnerDirective implements OnChanges, OnDestroy {
+    /** When `true`, the spinner overlay is rendered inside the host element. */
+    rcSpinner: boolean;
+    /** Colour status forwarded to the inner `rc-spinner`. Default: `'primary'` */
+    rcSpinnerStatus: RcSpinnerStatus;
+    /** Size forwarded to the inner `rc-spinner`. Default: `'md'` */
+    rcSpinnerSize: RcSpinnerSize;
+    /** Optional message label forwarded to the inner `rc-spinner`. */
+    rcSpinnerMessage: string;
+    private readonly _vcr;
+    private readonly _el;
+    private readonly _renderer;
+    private _spinnerRef;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcSpinnerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcSpinnerDirective, "[rcSpinner]", never, { "rcSpinner": { "alias": "rcSpinner"; "required": false; }; "rcSpinnerStatus": { "alias": "rcSpinnerStatus"; "required": false; }; "rcSpinnerSize": { "alias": "rcSpinnerSize"; "required": false; }; "rcSpinnerMessage": { "alias": "rcSpinnerMessage"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Status colour variant for the progress bar fill. */
+type RcProgressBarStatus = 'primary' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * A themed horizontal progress bar — determinate or indeterminate.
+ *
+ * Set `[value]` (0–100) for a standard progress bar. Set `[indeterminate]="true"`
+ * for an animated looping bar (value is ignored).
+ *
+ * @example Basic
+ * ```html
+ * <rc-progress-bar [value]="60"></rc-progress-bar>
+ * ```
+ *
+ * @example Status colours
+ * ```html
+ * <rc-progress-bar [value]="80" status="success"></rc-progress-bar>
+ * <rc-progress-bar [value]="20" status="danger"></rc-progress-bar>
+ * ```
+ *
+ * @example Striped
+ * ```html
+ * <rc-progress-bar [value]="55" [striped]="true" status="info"></rc-progress-bar>
+ * ```
+ *
+ * @example Indeterminate
+ * ```html
+ * <rc-progress-bar [indeterminate]="true"></rc-progress-bar>
+ * ```
+ *
+ * @example With label
+ * ```html
+ * <rc-progress-bar [value]="72" label="Uploading…"></rc-progress-bar>
+ * ```
+ */
+declare class RcProgressBarComponent {
+    /** Progress value from 0 to 100. Ignored when `indeterminate` is true. Default: `0` */
+    value: number;
+    /** Colour variant of the fill. Default: `'primary'` */
+    status: RcProgressBarStatus;
+    /** When true, shows an animated looping bar. Default: `false` */
+    indeterminate: boolean;
+    /** When true, adds a diagonal stripe pattern to the fill. Default: `false` */
+    striped: boolean;
+    /** Optional text label shown above the bar. When set, also shows the % value. */
+    label: string;
+    /** @internal Clamped value between 0 and 100. */
+    get _clamped(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcProgressBarComponent, "rc-progress-bar", never, { "value": { "alias": "value"; "required": false; }; "status": { "alias": "status"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** An individual file entry tracked by the upload component. */
+interface RcUploadedFile {
+    /** Underlying native `File` object. */
+    file: File;
+    /** Human-readable file size string (e.g. `"2.4 MB"`). */
+    sizeLabel: string;
+    /** Whether this file failed validation (size, type, or count). */
+    error?: string;
+}
+/**
+ * A drag-and-drop / click-to-browse file upload component with inline validation.
+ *
+ * Selected files appear as a list below the drop zone. Validation errors are
+ * shown per-file. Emits the full `File[]` (valid files only) on every change.
+ *
+ * @example Basic single-file upload
+ * ```html
+ * <rc-file-upload (filesChange)="onFiles($event)"></rc-file-upload>
+ * ```
+ *
+ * @example Multiple files with restrictions
+ * ```html
+ * <rc-file-upload
+ *   [multiple]="true"
+ *   accept=".png,.jpg,.jpeg"
+ *   [maxFileSizeMb]="5"
+ *   [maxFiles]="4"
+ *   (filesChange)="attachments = $event"
+ * ></rc-file-upload>
+ * ```
+ *
+ * @example Disabled
+ * ```html
+ * <rc-file-upload [disabled]="true"></rc-file-upload>
+ * ```
+ */
+declare class RcFileUploadComponent {
+    private readonly _input;
+    /** Allow selecting multiple files. Default: `false` */
+    multiple: boolean;
+    /** Primary text in the drop zone. Default: `'Drop files here or'` */
+    dropTitleLabel: string;
+    /** Clickable browse-text in the drop zone. Default: `'browse'` */
+    browseLabel: string;
+    /** Hint prefix when an `accept` filter is set. Default: `'Accepted:'` */
+    acceptedLabel: string;
+    /** Hint size prefix. Default: `'· up to'` */
+    upToLabel: string;
+    /** Unit label for file size. Default: `'MB'` */
+    mbLabel: string;
+    /** Hint max-file-count prefix (inline). Default: `'· max'` */
+    maxFilesHintLabel: string;
+    /** Unit label after max file count. Default: `'files'` */
+    filesLabel: string;
+    /** Hint when only a file-count limit is set, no type filter. Default: `'Max files:'` */
+    onlyMaxFilesLabel: string;
+    /** Hint label for the max-file-size line. Default: `'Max file size:'` */
+    maxFileSizeLabel: string;
+    /** Hint when there are no restrictions. Default: `'Any file type accepted'` */
+    anyFileTypeLabel: string;
+    /** ARIA label for the remove-file button. Default: `'Remove file'` */
+    removeFileAriaLabel: string;
+    /** Error message factory when too many files are selected. */
+    maxFilesErrorFn: (max: number) => string;
+    /** Error message factory when a file exceeds the size limit. */
+    fileSizeErrorFn: (mb: number) => string;
+    /** Error message when a file type is not allowed. Default: `'File type not allowed'` */
+    fileTypeErrorLabel: string;
+    /**
+     * Comma-separated list of accepted MIME types or file extensions.
+     * E.g. `".pdf,.png,image/*"`. Passed directly to the native input.
+     */
+    accept: string;
+    /** Maximum individual file size in megabytes. `0` means no limit. Default: `0` */
+    maxFileSizeMb: number;
+    /**
+     * Maximum number of files allowed (only meaningful when `multiple = true`).
+     * `0` means no limit. Default: `0`
+     */
+    maxFiles: number;
+    /** Disables all interaction. Default: `false` */
+    disabled: boolean;
+    /** Emits the valid `File[]` whenever the selection changes. */
+    readonly filesChange: EventEmitter<File[]>;
+    /** @internal */
+    readonly _dragOver: i0.WritableSignal<boolean>;
+    /** @internal */
+    readonly _files: i0.WritableSignal<RcUploadedFile[]>;
+    /** @internal Whether any file has a validation error. */
+    readonly _hasErrors: i0.Signal<boolean>;
+    /** @internal Called by the native input `change` event. */
+    _onInputChange(event: Event): void;
+    /** @internal Called on drop. */
+    _onDrop(event: DragEvent): void;
+    /** @internal Remove a file from the list. */
+    _removeFile(entry: RcUploadedFile): void;
+    private _addFiles;
+    private _validate;
+    private _emitValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcFileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcFileUploadComponent, "rc-file-upload", never, { "multiple": { "alias": "multiple"; "required": false; }; "dropTitleLabel": { "alias": "dropTitleLabel"; "required": false; }; "browseLabel": { "alias": "browseLabel"; "required": false; }; "acceptedLabel": { "alias": "acceptedLabel"; "required": false; }; "upToLabel": { "alias": "upToLabel"; "required": false; }; "mbLabel": { "alias": "mbLabel"; "required": false; }; "maxFilesHintLabel": { "alias": "maxFilesHintLabel"; "required": false; }; "filesLabel": { "alias": "filesLabel"; "required": false; }; "onlyMaxFilesLabel": { "alias": "onlyMaxFilesLabel"; "required": false; }; "maxFileSizeLabel": { "alias": "maxFileSizeLabel"; "required": false; }; "anyFileTypeLabel": { "alias": "anyFileTypeLabel"; "required": false; }; "removeFileAriaLabel": { "alias": "removeFileAriaLabel"; "required": false; }; "maxFilesErrorFn": { "alias": "maxFilesErrorFn"; "required": false; }; "fileSizeErrorFn": { "alias": "fileSizeErrorFn"; "required": false; }; "fileTypeErrorLabel": { "alias": "fileTypeErrorLabel"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "maxFileSizeMb": { "alias": "maxFileSizeMb"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "filesChange": "filesChange"; }, never, never, true, never>;
+}
+/**
+ * A styled virtual-scrolling viewport backed by Angular CDK.
+ *
+ * Renders only the items visible in the scroll window — constant DOM size
+ * regardless of list length.
+ *
+ * Pass the data via `[items]` and define the row template with `<ng-template let-item>`.
+ *
+ * @example
+ * ```html
+ * <rc-virtual-scroll-viewport [items]="rows" [itemSize]="48" height="400px">
+ *   <ng-template let-row>
+ *     <div class="list-row">{{ row.name }}</div>
+ *   </ng-template>
+ * </rc-virtual-scroll-viewport>
+ * ```
+ */
+declare class RcVirtualScrollViewportComponent<T = unknown> {
+    /** The data array to render. */
+    items: T[];
+    /** Height of each item in pixels. All items must be the same height. Default: `48` */
+    itemSize: number;
+    /**
+     * CSS height of the scrollable container, e.g. `'400px'` or `'60vh'`.
+     * Default: `'400px'`
+     */
+    height: string;
+    /**
+     * Minimum number of pixels outside the viewport before new items are rendered.
+     * Default: `200`
+     */
+    minBufferPx: number;
+    /**
+     * Maximum pixel buffer to render beyond the visible area.
+     * Default: `400`
+     */
+    maxBufferPx: number;
+    /** Optional trackBy function, same signature as `*ngFor`'s `trackBy`. */
+    trackBy?: (index: number, item: T) => unknown;
+    /** The `<ng-template let-item>` content child used to render each row. */
+    itemTemplate: TemplateRef<any>;
+    private readonly _cdkViewport;
+    /** Scroll to a specific index in the list. */
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    /** Smooth-scroll back to the first item. */
+    scrollToStart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcVirtualScrollViewportComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcVirtualScrollViewportComponent<any>, "rc-virtual-scroll-viewport", never, { "items": { "alias": "items"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; "height": { "alias": "height"; "required": false; }; "minBufferPx": { "alias": "minBufferPx"; "required": false; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+}
+type RcTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Lightweight tooltip directive powered by Angular CDK Overlay.
+ *
+ * Apply `[rcTooltip]` to any element. The tooltip appears on mouse enter and
+ * keyboard focus, and disappears on leave / blur.
+ *
+ * @example Plain text tooltip
+ * ```html
+ * <button rcButton rcTooltip="Save the document">Save</button>
+ * ```
+ *
+ * @example Positioned tooltip
+ * ```html
+ * <rc-icon name="info" rcTooltip="More information" rcTooltipPosition="right"></rc-icon>
+ * ```
+ *
+ * @example Disabled tooltip
+ * ```html
+ * <span [rcTooltip]="hint" [rcTooltipDisabled]="!showHints">Hover me</span>
+ * ```
+ */
+declare class RcTooltipDirective implements OnDestroy {
+    /** Tooltip text. Set to an empty string to disable. */
+    text: string;
+    /** Side the tooltip appears on. Default: `'top'` */
+    rcTooltipPosition: RcTooltipPosition;
+    /** Suppresses the tooltip entirely when true. Default: `false` */
+    rcTooltipDisabled: boolean;
+    private readonly _overlay;
+    private readonly _posBuilder;
+    private readonly _elRef;
+    private readonly _vcr;
+    private _overlayRef;
+    private _compRef;
+    private _hideTimeout;
+    _show(): void;
+    _hide(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcTooltipDirective, "[rcTooltip]", never, { "text": { "alias": "rcTooltip"; "required": false; }; "rcTooltipPosition": { "alias": "rcTooltipPosition"; "required": false; }; "rcTooltipDisabled": { "alias": "rcTooltipDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * A single item inside an `<rc-menu>`.
+ *
+ * Renders as a full-width button. Optionally accepts a leading icon via `icon`.
+ *
+ * @example
+ * ```html
+ * <rc-menu-item icon="edit-2-outline" (itemClick)="edit()">Edit</rc-menu-item>
+ * <rc-menu-item icon="trash-2-outline" [danger]="true" (itemClick)="delete()">Delete</rc-menu-item>
+ * <rc-menu-item [disabled]="true">Unavailable</rc-menu-item>
+ * ```
+ */
+declare class RcMenuItemComponent {
+    /** Eva icon name for the leading icon slot. */
+    icon: string;
+    /** Renders the item with danger (red) text colouring. Default: `false` */
+    danger: boolean;
+    /** Prevents clicking. Default: `false` */
+    disabled: boolean;
+    /** Emitted when this item is clicked (and not disabled). */
+    readonly itemClick: EventEmitter<void>;
+    private readonly _close;
+    /** @internal */
+    _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcMenuItemComponent, "rc-menu-item", never, { "icon": { "alias": "icon"; "required": false; }; "danger": { "alias": "danger"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "itemClick": "itemClick"; }, never, ["*"], true, never>;
+}
+/**
+ * A thin horizontal rule that visually groups menu items.
+ *
+ * @example
+ * ```html
+ * <rc-menu-item>Edit</rc-menu-item>
+ * <rc-menu-separator></rc-menu-separator>
+ * <rc-menu-item danger>Delete</rc-menu-item>
+ * ```
+ */
+declare class RcMenuSeparatorComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcMenuSeparatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcMenuSeparatorComponent, "rc-menu-separator", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A floating menu panel populated with `<rc-menu-item>` and `<rc-menu-separator>`.
+ *
+ * Open it by attaching `[rcMenuTriggerFor]="myMenu"` to any element.
+ *
+ * @example
+ * ```html
+ * <button rcButton [rcMenuTriggerFor]="actions">Actions <rc-icon name="chevron-down"></rc-icon></button>
+ *
+ * <rc-menu #actions>
+ *   <rc-menu-item icon="edit-2-outline" (itemClick)="onEdit()">Edit</rc-menu-item>
+ *   <rc-menu-item icon="copy-outline"   (itemClick)="onDuplicate()">Duplicate</rc-menu-item>
+ *   <rc-menu-separator></rc-menu-separator>
+ *   <rc-menu-item icon="trash-2-outline" [danger]="true" (itemClick)="onDelete()">Delete</rc-menu-item>
+ * </rc-menu>
+ * ```
+ */
+declare class RcMenuComponent {
+    /** Minimum width of the panel in pixels. Default: `160` */
+    minWidth: number;
+    /** @internal Emitted when the panel should close (e.g. Escape key). */
+    readonly _closeRequest: EventEmitter<void>;
+    readonly _panelTpl: TemplateRef<unknown>;
+    readonly _items: QueryList<RcMenuItemComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcMenuComponent, "rc-menu", never, { "minWidth": { "alias": "minWidth"; "required": false; }; }, {}, ["_items"], ["*"], true, never>;
+}
+/**
+ * Directive that opens an associated `<rc-menu>` in a CDK overlay when the
+ * host element is clicked.
+ *
+ * @example
+ * ```html
+ * <button rcButton [rcMenuTriggerFor]="myMenu">Open ▾</button>
+ * <rc-menu #myMenu>
+ *   <rc-menu-item (itemClick)="onAction()">Action</rc-menu-item>
+ * </rc-menu>
+ * ```
+ */
+declare class RcMenuTriggerDirective implements OnDestroy {
+    /** The `<rc-menu>` template to open. */
+    rcMenuTriggerFor: RcMenuComponent;
+    /** Alignment of the menu relative to the trigger. Default: `'start'` */
+    rcMenuAlign: 'start' | 'end';
+    readonly _isOpen: i0.WritableSignal<boolean>;
+    private readonly _overlay;
+    private readonly _el;
+    private readonly _vcr;
+    private _overlayRef;
+    private _portal;
+    /** @internal */
+    _toggle(): void;
+    /** @internal */
+    _open(): void;
+    private _close;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RcMenuTriggerDirective, "[rcMenuTriggerFor]", never, { "rcMenuTriggerFor": { "alias": "rcMenuTriggerFor"; "required": true; }; "rcMenuAlign": { "alias": "rcMenuAlign"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Infinite-scroll container that fires `(loadMore)` when a sentinel element
+ * near the bottom of the list enters the viewport.
+ *
+ * The host element acts as the scrollable container when `scrollable` is true.
+ * Place your list (or `<table rcTable>`) as content — the sentinel and spinner
+ * are rendered automatically.
+ *
+ * Uses the browser's `IntersectionObserver` API — no scroll event listeners.
+ *
+ * @example Basic list
+ * ```html
+ * <rc-infinite-scroll
+ *   [loading]="loading"
+ *   [hasMore]="hasMore"
+ *   (loadMore)="fetchMore()"
+ * >
+ *   <div *ngFor="let item of items">{{ item.name }}</div>
+ * </rc-infinite-scroll>
+ * ```
+ *
+ * @example With rc-table inside
+ * ```html
+ * <rc-infinite-scroll [loading]="loading" [hasMore]="hasMore" (loadMore)="fetch()">
+ *   <table rcTable [dataSource]="rows">
+ *     <!-- columns… -->
+ *   </table>
+ * </rc-infinite-scroll>
+ * ```
+ */
+declare class RcInfiniteScrollComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private sentinelRef;
+    private readonly zone;
+    private readonly elementRef;
+    /** Whether a load is currently in progress. While true `(loadMore)` won't fire. */
+    loading: boolean;
+    /**
+     * Set to `false` when all data has been fetched. Hides the sentinel and
+     * shows the end-of-list message.
+     */
+    hasMore: boolean;
+    /**
+     * Makes the host element itself the scrollable container (adds
+     * `overflow-y: auto` and a fixed height inherited from the parent).
+     * Default: `false` — the page scroll triggers loading.
+     */
+    scrollable: boolean;
+    /** Colour variant passed to the internal `<rc-spinner>`. Default: `'primary'` */
+    spinnerStatus: RcSpinnerStatus;
+    /** Optional message displayed beneath the spinner while loading. */
+    loadingMessage: string;
+    /** Whether to render the end-of-list message when `hasMore` is false. Default: `true` */
+    showEndMessage: boolean;
+    /** Text displayed when `hasMore` is false and `showEndMessage` is true. */
+    endMessage: string;
+    /**
+     * Root margin (in px) added to the bottom of the viewport — the `(loadMore)`
+     * event fires when the sentinel is within this many pixels of the fold.
+     * Default: `120`
+     */
+    threshold: number;
+    /**
+     * Emits when the sentinel element enters the viewport and `hasMore` is true
+     * and `loading` is false.
+     */
+    loadMore: EventEmitter<void>;
+    private observer?;
+    private isSentinelVisible;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcInfiniteScrollComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcInfiniteScrollComponent, "rc-infinite-scroll", never, { "loading": { "alias": "loading"; "required": false; }; "hasMore": { "alias": "hasMore"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "spinnerStatus": { "alias": "spinnerStatus"; "required": false; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; }; "showEndMessage": { "alias": "showEndMessage"; "required": false; }; "endMessage": { "alias": "endMessage"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; }, { "loadMore": "loadMore"; }, never, ["*"], true, never>;
+}
+/** Event emitted whenever the page index or page size changes. */
+interface RcPageEvent {
+    /** Current zero-based page index after the change. */
+    pageIndex: number;
+    /** Zero-based page index before the change. */
+    previousPageIndex: number;
+    /** Items shown per page after the change. */
+    pageSize: number;
+    /** Total number of items. */
+    length: number;
+}
+/** A page-number token — either a 1-based number or `'...'` for an ellipsis gap. */
+type RcPaginatorPage = number | '...';
+/**
+ * A full-featured paginator for navigating through paged data.
+ *
+ * Generates page-number buttons (with ellipsis for large ranges) and optionally
+ * an inline page-size selector. Emits `(pageChange)` whenever the user navigates.
+ *
+ * All page indexes are **zero-based** — the first page is `pageIndex = 0`.
+ *
+ * @example Basic (bind to rc-table dataSource)
+ * ```html
+ * <rc-paginator
+ *   [length]="total"
+ *   [pageIndex]="pageIndex"
+ *   [pageSize]="pageSize"
+ *   (pageChange)="onPage($event)"
+ * ></rc-paginator>
+ * ```
+ *
+ * @example With page-size selector
+ * ```html
+ * <rc-paginator
+ *   [length]="total"
+ *   [pageIndex]="pageIndex"
+ *   [pageSize]="pageSize"
+ *   [pageSizeOptions]="[10, 25, 50, 100]"
+ *   (pageChange)="onPage($event)"
+ * ></rc-paginator>
+ * ```
+ */
+declare class RcPaginatorComponent implements OnChanges {
+    /** Total number of items in the data set. */
+    length: number;
+    /** Zero-based index of the currently displayed page. Default: `0` */
+    pageIndex: number;
+    /** Number of items shown per page. Default: `10` */
+    pageSize: number;
+    /**
+     * Array of page-size options rendered in the size selector.
+     * Pass an empty array (default) to hide the selector entirely.
+     */
+    pageSizeOptions: number[];
+    /**
+     * Whether to render First-page and Last-page shortcut buttons.
+     * Default: `true`
+     */
+    showFirstLast: boolean;
+    /**
+     * Maximum number of page-number buttons to show before collapsing with
+     * ellipsis. Must be odd and ≥ 5. Default: `7`
+     */
+    maxPageButtons: number;
+    /** ARIA label for the paginator host element. */
+    navigationAriaLabel: string;
+    /** Label text next to the page-size selector. */
+    rowsPerPageLabel: string;
+    /** ARIA label for the page-size selector. */
+    rowsPerPageAriaLabel: string;
+    /** ARIA label for the First-page button. */
+    firstPageAriaLabel: string;
+    /** ARIA label for the Previous-page button. */
+    previousPageAriaLabel: string;
+    /** ARIA label for the Next-page button. */
+    nextPageAriaLabel: string;
+    /** ARIA label for the Last-page button. */
+    lastPageAriaLabel: string;
+    /**
+     * Function that returns the ARIA label for a numbered page button.
+     * Receives the 1-based page number.
+     */
+    pageAriaLabelFn: (page: number) => string;
+    /**
+     * Function that builds the range label shown between the nav and the size
+     * selector. Receives `(start, end, length)` — all 1-based.
+     * Default produces `"1 – 10 of 87"`.
+     */
+    rangeLabelFn: (start: number, end: number, length: number) => string;
+    /** Emitted when the page index or page size changes. */
+    pageChange: EventEmitter<RcPageEvent>;
+    get pageCount(): number;
+    get isFirstPage(): boolean;
+    get isLastPage(): boolean;
+    get rangeLabel(): string;
+    pages: RcPaginatorPage[];
+    ngOnChanges(changes: SimpleChanges): void;
+    firstPage(): void;
+    prevPage(): void;
+    nextPage(): void;
+    lastPage(): void;
+    goToPage(index: number): void;
+    onSizeChange(value: unknown): void;
+    private emit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RcPaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RcPaginatorComponent, "rc-paginator", never, { "length": { "alias": "length"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "showFirstLast": { "alias": "showFirstLast"; "required": false; }; "maxPageButtons": { "alias": "maxPageButtons"; "required": false; }; "navigationAriaLabel": { "alias": "navigationAriaLabel"; "required": false; }; "rowsPerPageLabel": { "alias": "rowsPerPageLabel"; "required": false; }; "rowsPerPageAriaLabel": { "alias": "rowsPerPageAriaLabel"; "required": false; }; "firstPageAriaLabel": { "alias": "firstPageAriaLabel"; "required": false; }; "previousPageAriaLabel": { "alias": "previousPageAriaLabel"; "required": false; }; "nextPageAriaLabel": { "alias": "nextPageAriaLabel"; "required": false; }; "lastPageAriaLabel": { "alias": "lastPageAriaLabel"; "required": false; }; "pageAriaLabelFn": { "alias": "pageAriaLabelFn"; "required": false; }; "rangeLabelFn": { "alias": "rangeLabelFn"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+export { DARK_THEME, DEFAULT_THEME, RC_ACCORDION, RC_BUILT_IN_JS_THEMES, RC_DIALOG_DATA, RC_JS_THEMES, RC_RADIO_GROUP, RC_SIDENAV_CONTAINER, RC_SORT, RC_TABLE_DIRECTIVES, RC_THEME_OPTIONS, RcAccordionComponent, RcAccordionItemComponent, RcAlertComponent, RcAutocompleteComponent, RcBadgeComponent, RcButtonComponent, RcCardComponent, RcCellDefDirective, RcCellDirective, RcCheckboxComponent, RcChipComponent, RcColumnDefDirective, RcDatepickerComponent, RcDialogActionsDirective, RcDialogContainerComponent, RcDialogContentDirective, RcDialogRef, RcDialogService, RcDialogTitleDirective, RcFileUploadComponent, RcFooterCellDefDirective, RcFooterCellDirective, RcFooterRowComponent, RcFooterRowDefDirective, RcHeaderCellDefDirective, RcHeaderCellDirective, RcHeaderRowComponent, RcHeaderRowDefDirective, RcIconComponent, RcInfiniteScrollComponent, RcInputDirective, RcJSThemesRegistry, RcLayout, RcMenuComponent, RcMenuItemComponent, RcMenuSeparatorComponent, RcMenuTriggerDirective, RcNavbarActionsDirective, RcNavbarBrandDirective, RcNavbarComponent, RcNavbarRowComponent, RcNavbarSpacerComponent, RcNoDataRowDirective, RcOptionComponent, RcPaginatorComponent, RcProgressBarComponent, RcRadioButtonComponent, RcRadioGroupComponent, RcRowComponent, RcRowDefDirective, RcSelectComponent, RcSidenavComponent, RcSidenavContainerComponent, RcSidenavContentComponent, RcSliderComponent, RcSortDirective, RcSortHeaderComponent, RcSpinnerComponent, RcSpinnerDirective, RcTabComponent, RcTableComponent, RcTableDataSource, RcTabsComponent, RcThemeModule, RcThemeService, RcToastComponent, RcToastContainerComponent, RcToastService, RcToggleComponent, RcTooltipDirective, RcTreeComponent, RcTreeNodeComponent, RcVirtualScrollViewportComponent, ResolveComponents, provideRcTheme };
+export type { RcAccordionVariant, RcAlertStatus, RcAlertVariant, RcAutocompleteOption, RcAutocompleteSize, RcAutocompleteStatus, RcBadgeSize, RcBadgeStatus, RcBadgeVariant, RcButtonSize, RcButtonStatus, RcButtonVariant, RcCheckboxSize, RcCheckboxStatus, RcChipSize, RcChipStatus, RcDatepickerMode, RcDatepickerSize, RcDatepickerStatus, RcDialogConfig, RcIconStatus, RcInputSize, RcInputStatus, RcJSThemeOptions, RcJSThemeVariable, RcNavbarColor, RcNavbarPosition, RcPageEvent, RcPaginatorPage, RcProgressBarStatus, RcRadioSize, RcSelectSize, RcSelectStatus, RcSidenavMode, RcSidenavPosition, RcSliderSize, RcSliderStatus, RcSortDirection, RcSortState, RcSpinnerSize, RcSpinnerStatus, RcTabStatus, RcTabsSize, RcThemeChange, RcThemeOptions, RcToastConfig, RcToastPosition, RcToastRef, RcToastStatus, RcToggleSize, RcTooltipPosition, RcTreeNodeData, RcTreeSelectionMode, RcUploadedFile };