@raqm/ui 0.0.0-stage → 0.1.0

package/types/raqm-ui-questionnaire.d.ts

@@ -0,0 +1,217 @@
+import * as i0 from "@angular/core";
+interface RaqmQuestionnaireChoice {
+  value: string;
+  label: string;
+  description?: string;
+}
+interface RaqmQuestionnaireItem {
+  name: string;
+  title: string;
+  description?: string;
+  required?: boolean;
+  multiple?: boolean;
+  choices: readonly RaqmQuestionnaireChoice[];
+  input?: {
+    label: string;
+    placeholder?: string;
+  };
+  visible?: (answers: RaqmQuestionnaireAnswers) => boolean;
+  validate?: (answers: readonly string[], allAnswers: RaqmQuestionnaireAnswers) => string | undefined;
+}
+type RaqmQuestionnaireAnswers = Record<string, string[]>;
+export declare class RaqmQuestionnaireComponent {
+  private readonly host;
+  private readonly changeDetector;
+  private readonly pendingFocus;
+  constructor();
+  readonly id: string;
+  readonly items: import("@angular/core").InputSignal<readonly RaqmQuestionnaireItem[]>;
+  readonly submitted: import("@angular/core").OutputEmitterRef<RaqmQuestionnaireAnswers>;
+  readonly answers: import("@angular/core").ModelSignal<RaqmQuestionnaireAnswers>;
+  readonly currentItem: import("@angular/core").ModelSignal<string | undefined>;
+  readonly shortcuts: import("@angular/core").InputSignal<"none" | "letters" | "numbers">;
+  readonly composed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Copy for the built-in navigation; application-supplied. */
+  readonly labels: import("@angular/core").InputSignal<{
+    previous: string;
+    skip: string;
+    next: string;
+    submit: string;
+  }>;
+  /** Required-item error message; application-supplied. */
+  readonly requiredMessage: import("@angular/core").InputSignal<string | undefined>;
+  /** Accessible name of the default mode's progressbar. */
+  readonly progressLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly index: import("@angular/core").WritableSignal<number>;
+  readonly freeformValues: import("@angular/core").WritableSignal<Record<string, string>>;
+  readonly error: import("@angular/core").WritableSignal<string>;
+  /** Whether the current item failed validation, including a required item with no message. */
+  readonly invalid: import("@angular/core").WritableSignal<boolean>;
+  readonly visibleItems: import("@angular/core").Signal<RaqmQuestionnaireItem[]>;
+  readonly current: import("@angular/core").Signal<RaqmQuestionnaireItem>;
+  readonly position: import("@angular/core").Signal<number>;
+  descriptionId(name: string): string;
+  errorId(name: string): string;
+  describedBy(name: string, hasDescription: boolean, hasError?: boolean): string | null;
+  selected(value: string): boolean;
+  shortcut(index: number): string;
+  onKey(event: KeyboardEvent): void;
+  choose(value: string, checked: boolean): void;
+  freeform(value: string): void;
+  previous(): void;
+  private focusCurrent;
+  next(skip?: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmQuestionnaireComponent, "raqm-questionnaire", never, {
+    "items": {
+      "alias": "items";
+      "required": true;
+      "isSignal": true;
+    };
+    "answers": {
+      "alias": "answers";
+      "required": false;
+      "isSignal": true;
+    };
+    "currentItem": {
+      "alias": "currentItem";
+      "required": false;
+      "isSignal": true;
+    };
+    "shortcuts": {
+      "alias": "shortcuts";
+      "required": false;
+      "isSignal": true;
+    };
+    "composed": {
+      "alias": "composed";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": true;
+      "isSignal": true;
+    };
+    "requiredMessage": {
+      "alias": "requiredMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "progressLabel": {
+      "alias": "progressLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "submitted": "submitted";
+    "answers": "answersChange";
+    "currentItem": "currentItemChange";
+  }, never, ["*"], true, never>;
+}
+/** Progress part; the application names it with `aria-label` on the host. */
+export declare class RaqmQuestionnaireProgressComponent {
+  protected readonly root: RaqmQuestionnaireComponent;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireProgressComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmQuestionnaireProgressComponent, "raqm-questionnaire-progress", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireItemDirective {
+  readonly root: RaqmQuestionnaireComponent;
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** External cross-field validation state, combined with the root's per-item check. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly active: import("@angular/core").Signal<boolean>;
+  readonly description: import("@angular/core").Signal<RaqmQuestionnaireDescriptionDirective | undefined>;
+  readonly errorPart: import("@angular/core").Signal<RaqmQuestionnaireErrorComponent | undefined>;
+  readonly errorMessage: import("@angular/core").Signal<string | undefined>;
+  protected onKey(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireItemDirective, "fieldset[raqm-questionnaire-item]", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["description", "errorPart"], never, true, never>;
+}
+export declare class RaqmQuestionnaireTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireTitleDirective, "[raqm-questionnaire-title]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireDescriptionDirective {
+  protected readonly item: RaqmQuestionnaireItemDirective;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireDescriptionDirective, "[raqm-questionnaire-description]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireChoicesDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireChoicesDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireChoicesDirective, "[raqm-questionnaire-choices]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireChoiceDirective {
+  protected readonly item: RaqmQuestionnaireItemDirective;
+  protected readonly definition: import("@angular/core").Signal<import("@raqm/ui/questionnaire").RaqmQuestionnaireItem | undefined>;
+  readonly value: import("@angular/core").InputSignal<string>;
+  protected onChange(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireChoiceDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireChoiceDirective, "input[raqm-questionnaire-choice]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireInputDirective {
+  protected readonly item: RaqmQuestionnaireItemDirective;
+  protected onInput(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireInputDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireInputDirective, "input[raqm-questionnaire-input]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireErrorComponent {
+  protected readonly item: RaqmQuestionnaireItemDirective;
+  /** External validation message; falls back to the root's own item error. */
+  readonly message: import("@angular/core").InputSignal<string | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireErrorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmQuestionnaireErrorComponent, "raqm-questionnaire-error", never, {
+    "message": {
+      "alias": "message";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireActionsDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireActionsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireActionsDirective, "[raqm-questionnaire-actions]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnairePreviousDirective {
+  protected readonly root: RaqmQuestionnaireComponent;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnairePreviousDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnairePreviousDirective, "button[raqm-questionnaire-previous]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireSkipDirective {
+  protected readonly root: RaqmQuestionnaireComponent;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireSkipDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireSkipDirective, "button[raqm-questionnaire-skip]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireNextDirective {
+  protected readonly root: RaqmQuestionnaireComponent;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireNextDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireNextDirective, "button[raqm-questionnaire-next]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmQuestionnaireSubmitDirective {
+  protected readonly root: RaqmQuestionnaireComponent;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmQuestionnaireSubmitDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmQuestionnaireSubmitDirective, "button[raqm-questionnaire-submit]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmQuestionnaire: readonly [typeof RaqmQuestionnaireComponent, typeof RaqmQuestionnaireProgressComponent, typeof RaqmQuestionnaireItemDirective, typeof RaqmQuestionnaireTitleDirective, typeof RaqmQuestionnaireDescriptionDirective, typeof RaqmQuestionnaireChoicesDirective, typeof RaqmQuestionnaireChoiceDirective, typeof RaqmQuestionnaireInputDirective, typeof RaqmQuestionnaireErrorComponent, typeof RaqmQuestionnaireActionsDirective, typeof RaqmQuestionnairePreviousDirective, typeof RaqmQuestionnaireSkipDirective, typeof RaqmQuestionnaireNextDirective, typeof RaqmQuestionnaireSubmitDirective];
+export type { RaqmQuestionnaireAnswers, RaqmQuestionnaireChoice, RaqmQuestionnaireItem };

package/types/raqm-ui-radio-group.d.ts

@@ -0,0 +1,48 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+/**
+ * Attaches the `raqm-radio` class to a native `<input>` and sets `type="radio"` when absent.
+ *
+ * @remarks
+ * `(change)` emits the directive's `value`, so non-string bindings keep working as with Angular's
+ * built-in radio accessor; native `name` grouping and `required` stay authoritative.
+ */
+export declare class RaqmRadioDirective implements ControlValueAccessor {
+  private readonly host;
+  private onChange;
+  private onTouched;
+  private model;
+  private hasModel;
+  private disabledStateFired;
+  /** The value this radio contributes to the group; the native default is `on`. */
+  readonly value: import("@angular/core").InputSignal<unknown>;
+  constructor();
+  writeValue(value: unknown): void;
+  registerOnChange(fn: (value: unknown) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected handleChange(): void;
+  protected handleBlur(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmRadioDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmRadioDirective, "input[raqm-radio]", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Attaches `raqm-radio-group` and gives non-fieldset hosts `role="radiogroup"`.
+ *
+ * @remarks
+ * A `fieldset` keeps its native grouping and gets no role; grouping, focus and keyboard stay
+ * browser-owned, and the accessible name is application-owned.
+ */
+export declare class RaqmRadioGroupDirective {
+  private readonly host;
+  protected readonly role: string | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmRadioGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmRadioGroupDirective, "[raqm-radio-group]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmRadioGroup: readonly [typeof RaqmRadioGroupDirective, typeof RaqmRadioDirective];

package/types/raqm-ui-resizable.d.ts

@@ -0,0 +1,98 @@
+import * as i0 from "@angular/core";
+import { ElementRef } from "@angular/core";
+/** Raqm resizable panel group — percentage-based panels with a draggable divider; the app supplies every accessible name. */
+export declare class RaqmResizablePanelGroupComponent {
+  /** A horizontal row by default; a bare `vertical` attribute makes a column. */
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly defaultSize: import("@angular/core").InputSignal<number>;
+  readonly minSize: import("@angular/core").InputSignal<number>;
+  readonly maxSize: import("@angular/core").InputSignal<number>;
+  readonly element: ElementRef<any>;
+  readonly panels: import("@angular/core").Signal<readonly RaqmResizablePanelDirective[]>;
+  readonly handles: import("@angular/core").Signal<readonly RaqmResizableHandleDirective[]>;
+  private readonly changed;
+  readonly sizes: import("@angular/core").Signal<number[]>;
+  panelIndex(panel: RaqmResizablePanelDirective): number;
+  handleIndex(handle: RaqmResizableHandleDirective): number;
+  bounds(index: number): {
+    min: number;
+    max: number;
+  };
+  resize(index: number, value: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmResizablePanelGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmResizablePanelGroupComponent, "raqm-resizable-panel-group", never, {
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultSize": {
+      "alias": "defaultSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "minSize": {
+      "alias": "minSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxSize": {
+      "alias": "maxSize";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["panels", "handles"], ["*"], true, never>;
+}
+/** Raqm resizable panel — one percentage-sized region; owns its id (the handle's `aria-controls` target) and flex-basis. */
+export declare class RaqmResizablePanelDirective {
+  private readonly group;
+  readonly id: string;
+  readonly defaultSize: import("@angular/core").InputSignal<number | undefined>;
+  readonly minSize: import("@angular/core").InputSignal<number | undefined>;
+  readonly maxSize: import("@angular/core").InputSignal<number | undefined>;
+  protected readonly basis: import("@angular/core").Signal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmResizablePanelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmResizablePanelDirective, "[raqm-resizable-panel]", never, {
+    "defaultSize": {
+      "alias": "defaultSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "minSize": {
+      "alias": "minSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxSize": {
+      "alias": "maxSize";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Raqm resizable handle — draggable `role="separator"`, focusable and keyboard-operable; accessible name is app-authored. */
+export declare class RaqmResizableHandleDirective {
+  readonly withHandle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly group: RaqmResizablePanelGroupComponent;
+  protected readonly index: import("@angular/core").Signal<number>;
+  protected readonly value: import("@angular/core").Signal<number>;
+  protected readonly bounds: import("@angular/core").Signal<{
+    min: number;
+    max: number;
+  }>;
+  private readonly element;
+  private readonly destroy;
+  private cleanup;
+  constructor();
+  protected onKey(event: KeyboardEvent): void;
+  protected onPointer(event: PointerEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmResizableHandleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmResizableHandleDirective, "[raqm-resizable-handle]", never, {
+    "withHandle": {
+      "alias": "withHandle";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const RaqmResizable: readonly [typeof RaqmResizablePanelGroupComponent, typeof RaqmResizablePanelDirective, typeof RaqmResizableHandleDirective];

package/types/raqm-ui-scroll-area.d.ts

@@ -0,0 +1,132 @@
+import * as i0 from "@angular/core";
+import { ElementRef, InjectionToken, Signal } from "@angular/core";
+interface ScrollAreaMetrics {
+  width: number;
+  height: number;
+  scrollWidth: number;
+  scrollHeight: number;
+  x: number;
+  y: number;
+  rtl: boolean;
+}
+/** Internal root contract; the token avoids a circular component dependency. */
+declare const SCROLL_AREA: InjectionToken<{
+  metrics: Signal<ScrollAreaMetrics>;
+  horizontal: Signal<boolean>;
+  vertical: Signal<boolean>;
+  scrolling: Signal<boolean>;
+  hovering: Signal<boolean>;
+  edges: Signal<{
+    xStart: boolean;
+    xEnd: boolean;
+    yStart: boolean;
+    yEnd: boolean;
+  }>;
+  refresh(): void;
+  scrollTo(orientation: "horizontal" | "vertical", offset: number): void;
+}>;
+/** Scroll area; the labelled native viewport is the sole keyboard/AT target and the overlay bars are `aria-hidden` and pointer-only. */
+export declare class RaqmScrollAreaComponent {
+  /** Required accessible name for the keyboard-focusable native viewport. */
+  readonly viewportLabel: import("@angular/core").InputSignal<string>;
+  readonly overflowEdgeThreshold: import("@angular/core").InputSignal<number | Partial<Record<"xStart" | "xEnd" | "yStart" | "yEnd", number>>>;
+  readonly viewport: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+  private readonly content;
+  private readonly host;
+  private readonly destroyRef;
+  private readonly bars;
+  protected readonly defaultVertical: import("@angular/core").Signal<boolean>;
+  readonly metrics: import("@angular/core").WritableSignal<ScrollAreaMetrics>;
+  readonly horizontal: import("@angular/core").Signal<boolean>;
+  readonly vertical: import("@angular/core").Signal<boolean>;
+  readonly scrolling: import("@angular/core").WritableSignal<boolean>;
+  readonly hovering: import("@angular/core").WritableSignal<boolean>;
+  private scrollTimer;
+  readonly edges: import("@angular/core").Signal<{
+    xStart: boolean;
+    xEnd: boolean;
+    yStart: boolean;
+    yEnd: boolean;
+  }>;
+  constructor();
+  /** Tracks the native scroll lifecycle without changing wheel or touch events. */
+  protected onScroll(): void;
+  refresh(): void;
+  /** Sets a clamped native offset measured from the logical start of the chosen axis. */
+  scrollTo(orientation: 'horizontal' | 'vertical', offset: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmScrollAreaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmScrollAreaComponent, "raqm-scroll-area", never, {
+    "viewportLabel": {
+      "alias": "viewportLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "overflowEdgeThreshold": {
+      "alias": "overflowEdgeThreshold";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["bars"], ["*", "raqm-scroll-bar"], true, never>;
+}
+/** Scroll bar overlay; `aria-hidden` and not a tab stop, because the viewport handles keyboard/AT scrolling. */
+export declare class RaqmScrollBarComponent {
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Keeps the internal thumb mounted without overflow; the Angular host always exists. */
+  readonly keepMounted: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly area: {
+    metrics: import("@angular/core").Signal<ScrollAreaMetrics>;
+    horizontal: import("@angular/core").Signal<boolean>;
+    vertical: import("@angular/core").Signal<boolean>;
+    scrolling: import("@angular/core").Signal<boolean>;
+    hovering: import("@angular/core").Signal<boolean>;
+    edges: import("@angular/core").Signal<{
+      xStart: boolean;
+      xEnd: boolean;
+      yStart: boolean;
+      yEnd: boolean;
+    }>;
+    refresh(): void;
+    scrollTo(orientation: "horizontal" | "vertical", offset: number): void;
+  };
+  private readonly host;
+  private readonly destroyRef;
+  private readonly trackSize;
+  private drag;
+  protected readonly overflow: import("@angular/core").Signal<boolean>;
+  private readonly geometry;
+  protected readonly thumbStyle: import("@angular/core").Signal<{
+    'block-size': string;
+    'inset-block-start': string;
+    'inline-size'?: undefined;
+    'inset-inline-start'?: undefined;
+  } | {
+    'inline-size': string;
+    'inset-inline-start': string;
+    'block-size'?: undefined;
+    'inset-block-start'?: undefined;
+  }>;
+  constructor();
+  /** Bridges only overlay-track wheel input; viewport wheel/touch remain native. */
+  private onTrackWheel;
+  private measure;
+  private coordinate;
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected endPointer(event: PointerEvent): void;
+  private endDrag;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmScrollBarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmScrollBarComponent, "raqm-scroll-bar", never, {
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+    "keepMounted": {
+      "alias": "keepMounted";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const RaqmScrollArea: readonly [typeof RaqmScrollAreaComponent, typeof RaqmScrollBarComponent];
+export {};