@raqm/ui 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,124 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnInit, Signal } from "@angular/core";
+interface RaqmAccordionItemRef {
+  /** Unique, non-empty item value used by the root's open-state contract. */
+  readonly value: string;
+}
+/** Root contract published under {@link RAQM_ACCORDION}; the dedicated token avoids a runtime module cycle. */
+interface RaqmAccordionContext {
+  readonly multiple: Signal<boolean>;
+  readonly disabled: Signal<boolean>;
+  isOpen(value: string): boolean;
+  /** Applies the root's open-state rules to an activated value (no-op if disabled). */
+  toggle(value: string): void;
+  register(item: RaqmAccordionItemRef): void;
+  unregister(item: RaqmAccordionItemRef): void;
+}
+/** Item contract; the item owns both ids so the trigger/content ARIA pair cannot drift. */
+interface RaqmAccordionItemContext {
+  readonly open: Signal<boolean>;
+  readonly effectiveDisabled: Signal<boolean>;
+  readonly triggerId: string;
+  readonly contentId: string;
+  toggle(): void;
+}
+/** Root token; injected optionally so a misplaced item renders and only logs a dev-mode error. */
+declare const RAQM_ACCORDION: InjectionToken<RaqmAccordionContext>;
+/** Item token; optional so a misplaced part renders and only logs a dev-mode error. */
+declare const RAQM_ACCORDION_ITEM: InjectionToken<RaqmAccordionItemContext>;
+/** Accordion root; carries no ARIA role (each trigger owns the heading) and keeps at most one open value in single mode. */
+export declare class RaqmAccordionComponent implements RaqmAccordionContext {
+  readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly value: import("@angular/core").ModelSignal<readonly string[]>;
+  readonly defaultValue: import("@angular/core").InputSignal<readonly string[]>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly items;
+  private readonly interacted;
+  private readonly openValues;
+  /** Whether the given value is currently expanded; single mode reads only the first entry. */
+  isOpen(value: string): boolean;
+  toggle(value: string): void;
+  /** Registers in DOM order; reads the bound `value`, so items must register from `ngOnInit`. */
+  register(item: RaqmAccordionItemRef): void;
+  /** Unregisters an item on destroy; never changes the open state. */
+  unregister(item: RaqmAccordionItemRef): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAccordionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAccordionComponent, "raqm-accordion", never, {
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultValue": {
+      "alias": "defaultValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+/** Accordion item; owns both element ids and registers from `ngOnInit` so the duplicate check sees the bound `value`. */
+export declare class RaqmAccordionItemComponent implements RaqmAccordionItemContext, OnInit {
+  private readonly accordion;
+  private readonly destroyRef;
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly instanceId;
+  readonly triggerId: string;
+  readonly contentId: string;
+  readonly effectiveDisabled: Signal<boolean>;
+  readonly open: Signal<boolean>;
+  private readonly ref;
+  constructor();
+  /** Registers the item with its parent root once its required `value` input is bound. */
+  ngOnInit(): void;
+  toggle(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAccordionItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAccordionItemComponent, "raqm-accordion-item", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Viewless directive on the real `<button>`, the only activation path; disabled triggers stay focusable via `aria-disabled`. */
+export declare class RaqmAccordionTriggerDirective {
+  private readonly item;
+  protected readonly open: Signal<boolean>;
+  protected readonly effectiveDisabled: Signal<boolean>;
+  protected readonly triggerId: Signal<string | null>;
+  protected readonly contentId: Signal<string | null>;
+  constructor();
+  protected onClick(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAccordionTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAccordionTriggerDirective, "button[raqm-accordion-trigger]", never, {}, {}, never, never, true, never>;
+}
+/** `role="region"` paired with its trigger by owned ids; stays mounted, animates by grid row, and is `inert` while closed. */
+export declare class RaqmAccordionContentComponent {
+  private readonly item;
+  protected readonly open: Signal<boolean>;
+  protected readonly contentId: Signal<string | null>;
+  protected readonly triggerId: Signal<string | null>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAccordionContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAccordionContentComponent, "raqm-accordion-content", never, {}, {}, never, ["*"], true, never>;
+}
+export declare const RaqmAccordion: readonly [typeof RaqmAccordionComponent, typeof RaqmAccordionItemComponent, typeof RaqmAccordionTriggerDirective, typeof RaqmAccordionContentComponent];
+export {};

package/types/raqm-ui-alert-dialog.d.ts

@@ -0,0 +1,81 @@
+import * as i1 from "@raqm/ui/dialog";
+import { RaqmDialogBaseComponent, RaqmDialogContentDirective, RaqmDialogTriggerDirective } from "@raqm/ui/dialog";
+import * as i0 from "@angular/core";
+/** Modal interruption sharing Dialog's stack, focus trap, scroll lock and teardown. */
+export declare class RaqmAlertDialogComponent extends RaqmDialogBaseComponent {
+  /** The compact alert layout; false is the normal layout. */
+  readonly small: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly closeButtonVisible: import("@angular/core").WritableSignal<boolean>;
+  protected readonly closeLabelText: import("@angular/core").WritableSignal<string | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAlertDialogComponent, "raqm-alert-dialog", ["raqmAlertDialog"], {
+    "small": {
+      "alias": "small";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Native opener reusing Dialog registration and disclosure ARIA. */
+export declare class RaqmAlertDialogTriggerDirective extends RaqmDialogTriggerDirective {
+  private readonly policy;
+  protected setOpeningPointer(event: PointerEvent): void;
+  protected resetOpeningPointer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogTriggerDirective, "button[raqm-alert-dialog-trigger]", never, {}, {}, never, never, true, never>;
+}
+/** Portal body template; the root owns the compact-size policy. */
+export declare class RaqmAlertDialogContentDirective extends RaqmDialogContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogContentDirective, "ng-template[raqm-alert-dialog-content]", ["raqmAlertDialogContent"], {}, {}, never, never, true, never>;
+}
+/** Passive header; media-aware responsive grid. */
+export declare class RaqmAlertDialogHeaderDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogHeaderDirective, "[raqm-alert-dialog-header]", never, {}, {}, never, never, true, never>;
+}
+/** Passive action footer; controls remain application-authored native buttons. */
+export declare class RaqmAlertDialogFooterDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogFooterDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogFooterDirective, "[raqm-alert-dialog-footer]", never, {}, {}, never, never, true, never>;
+}
+/** Optional media slot for an application-owned icon or image. */
+export declare class RaqmAlertDialogMediaDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogMediaDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogMediaDirective, "[raqm-alert-dialog-media]", never, {}, {}, never, never, true, never>;
+}
+/** Accessible title registered with the real alertdialog container. */
+export declare class RaqmAlertDialogTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogTitleDirective, "[raqm-alert-dialog-title]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogTitleDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Accessible description registered with the real alertdialog container. */
+export declare class RaqmAlertDialogDescriptionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogDescriptionDirective, "[raqm-alert-dialog-description]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogDescriptionDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Plain native action: compose raqm-button; activation does not implicitly close. */
+export declare class RaqmAlertDialogActionDirective {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogActionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogActionDirective, "button[raqm-alert-dialog-action]", never, {}, {}, never, never, true, never>;
+}
+/** Native cancel control using Dialog's single animated user-close path. */
+export declare class RaqmAlertDialogCancelDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDialogCancelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAlertDialogCancelDirective, "button[raqm-alert-dialog-cancel]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogCloseDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare const RaqmAlertDialog: readonly [typeof RaqmAlertDialogComponent, typeof RaqmAlertDialogTriggerDirective, typeof RaqmAlertDialogContentDirective, typeof RaqmAlertDialogHeaderDirective, typeof RaqmAlertDialogFooterDirective, typeof RaqmAlertDialogMediaDirective, typeof RaqmAlertDialogTitleDirective, typeof RaqmAlertDialogDescriptionDirective, typeof RaqmAlertDialogActionDirective, typeof RaqmAlertDialogCancelDirective];

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

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+/** Passive callout frame; static markup with no dismiss state or close output. */
+export declare class RaqmAlertComponent {
+  readonly destructive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly activeVariant: import("@angular/core").Signal<"destructive" | "default">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAlertComponent, "raqm-alert", never, {
+    "destructive": {
+      "alias": "destructive";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Heading selectors keep native heading semantics at the alert type scale. */
+export declare class RaqmAlertTitleComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertTitleComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAlertTitleComponent, "raqm-alert-title, h1[raqm-alert-title], h2[raqm-alert-title], h3[raqm-alert-title], h4[raqm-alert-title], h5[raqm-alert-title], h6[raqm-alert-title]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmAlertDescriptionComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertDescriptionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAlertDescriptionComponent, "raqm-alert-description, p[raqm-alert-description]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Placement only; the projected control keeps its own label, state and keyboard behaviour. */
+export declare class RaqmAlertActionComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAlertActionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAlertActionComponent, "raqm-alert-action", never, {}, {}, never, ["*"], true, never>;
+}
+export declare const RaqmAlert: readonly [typeof RaqmAlertComponent, typeof RaqmAlertTitleComponent, typeof RaqmAlertDescriptionComponent, typeof RaqmAlertActionComponent];

package/types/raqm-ui-aspect-ratio.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+/** Raqm aspect ratio — constrains projected content to a fixed width-to-height ratio. */
+export declare class RaqmAspectRatio {
+  readonly ratio: import("@angular/core").InputSignal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAspectRatio, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAspectRatio, "raqm-aspect-ratio", never, {
+    "ratio": {
+      "alias": "ratio";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,72 @@
+import * as i0 from "@angular/core";
+/** Passive surface; uploading and actions stay consumer-owned, and both sizes together throw. */
+export declare class RaqmAttachmentComponent {
+  readonly state: import("@angular/core").InputSignal<"idle" | "uploading" | "processing" | "error" | "done">;
+  readonly small: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly extraSmall: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly image: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly activeSize: import("@angular/core").Signal<"extra-small" | "default" | "small">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmAttachmentComponent, "raqm-attachment", never, {
+    "state": {
+      "alias": "state";
+      "required": false;
+      "isSignal": true;
+    };
+    "small": {
+      "alias": "small";
+      "required": false;
+      "isSignal": true;
+    };
+    "extraSmall": {
+      "alias": "extra-small";
+      "required": false;
+      "isSignal": true;
+    };
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+    "image": {
+      "alias": "image";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class RaqmAttachmentMediaDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentMediaDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentMediaDirective, "[raqm-attachment-media]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentContentDirective, "[raqm-attachment-content]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentTitleDirective, "[raqm-attachment-title]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentDescriptionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentDescriptionDirective, "[raqm-attachment-description]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentActionsDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentActionsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentActionsDirective, "[raqm-attachment-actions]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentActionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentActionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentActionDirective, "button[raqm-button][raqm-attachment-action]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentTriggerDirective {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentTriggerDirective, "button[raqm-attachment-trigger],a[raqm-attachment-trigger]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAttachmentGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAttachmentGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAttachmentGroupDirective, "[raqm-attachment-group]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmAttachment: readonly [typeof RaqmAttachmentComponent, typeof RaqmAttachmentMediaDirective, typeof RaqmAttachmentContentDirective, typeof RaqmAttachmentTitleDirective, typeof RaqmAttachmentDescriptionDirective, typeof RaqmAttachmentActionsDirective, typeof RaqmAttachmentActionDirective, typeof RaqmAttachmentTriggerDirective, typeof RaqmAttachmentGroupDirective];

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

@@ -0,0 +1,67 @@
+import * as i0 from "@angular/core";
+import { Signal } from "@angular/core";
+type RaqmAvatarStatus = 'idle' | 'loading' | 'loaded' | 'error';
+interface RaqmAvatarContext {
+  readonly status: Signal<RaqmAvatarStatus>;
+  setStatus(status: RaqmAvatarStatus): void;
+}
+/** Attaches `raqm-avatar` and owns the load state; `small` and `large` together throw. */
+export declare class RaqmAvatarDirective implements RaqmAvatarContext {
+  readonly small: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly large: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly activeSize: Signal<"default" | "small" | "large">;
+  private readonly statusState;
+  readonly status: Signal<RaqmAvatarStatus>;
+  setStatus(status: RaqmAvatarStatus): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarDirective, "span[raqm-avatar]", never, {
+    "small": {
+      "alias": "small";
+      "required": false;
+      "isSignal": true;
+    };
+    "large": {
+      "alias": "large";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Resolves the current source; other image attributes stay application-authored. */
+export declare class RaqmAvatarImageDirective {
+  private readonly host;
+  private readonly avatar;
+  readonly src: import("@angular/core").InputSignal<string>;
+  private generation;
+  protected readonly isHidden: Signal<boolean>;
+  constructor();
+  private resolve;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarImageDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarImageDirective, "img[raqm-avatar-image]", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class RaqmAvatarFallbackDirective {
+  private readonly avatar;
+  protected readonly isHidden: Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarFallbackDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarFallbackDirective, "span[raqm-avatar-fallback]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAvatarBadgeDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarBadgeDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarBadgeDirective, "span[raqm-avatar-badge]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAvatarGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarGroupDirective, "span[raqm-avatar-group]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmAvatarGroupCountDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmAvatarGroupCountDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmAvatarGroupCountDirective, "span[raqm-avatar-group-count]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmAvatar: readonly [typeof RaqmAvatarDirective, typeof RaqmAvatarImageDirective, typeof RaqmAvatarFallbackDirective, typeof RaqmAvatarBadgeDirective, typeof RaqmAvatarGroupDirective, typeof RaqmAvatarGroupCountDirective];
+export {};

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

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+type BadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost';
+/**
+ * Status pill on a native `<span>` or `<a>`; a real anchor keeps native navigation and focus.
+ * `raqm-badge` selects the appearance; `--raqm-badge-background`/`-foreground`/`-border` override colours.
+ */
+export declare class RaqmBadge {
+  /** Bare marker uses the default appearance. */
+  readonly appearance: import("@angular/core").InputSignal<"" | BadgeVariant>;
+  protected readonly activeVariant: import("@angular/core").Signal<BadgeVariant>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBadge, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBadge, "span[raqm-badge], a[raqm-badge]", never, {
+    "appearance": {
+      "alias": "raqm-badge";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export {};

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

@@ -0,0 +1,35 @@
+import * as i0 from "@angular/core";
+/** Native `<nav>` landmark; no role or tab stop is added, and the application supplies `aria-label`. */
+export declare class RaqmBreadcrumbComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbComponent, "nav[raqm-breadcrumb]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmBreadcrumbListComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbListComponent, "ol[raqm-breadcrumb-list]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmBreadcrumbItemComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbItemComponent, "li[raqm-breadcrumb-item]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Real anchor; navigation stays native and no click handler or tab stop is added. */
+export declare class RaqmBreadcrumbLinkComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbLinkComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbLinkComponent, "a[raqm-breadcrumb-link]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Carries `aria-current="page"`; not interactive and reads as plain text. */
+export declare class RaqmBreadcrumbPageComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbPageComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbPageComponent, "span[raqm-breadcrumb-page]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Decorative: `role="presentation"` and `aria-hidden`; only the default glyph mirrors in RTL. */
+export declare class RaqmBreadcrumbSeparatorComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbSeparatorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbSeparatorComponent, "li[raqm-breadcrumb-separator]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Decorative: `role="presentation"` and `aria-hidden`; the enclosing control carries the name. */
+export declare class RaqmBreadcrumbEllipsisComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmBreadcrumbEllipsisComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmBreadcrumbEllipsisComponent, "span[raqm-breadcrumb-ellipsis]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmBreadcrumb: readonly [typeof RaqmBreadcrumbComponent, typeof RaqmBreadcrumbListComponent, typeof RaqmBreadcrumbItemComponent, typeof RaqmBreadcrumbLinkComponent, typeof RaqmBreadcrumbPageComponent, typeof RaqmBreadcrumbSeparatorComponent, typeof RaqmBreadcrumbEllipsisComponent];

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

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+/** Button Group: `role="group"` with an application-supplied name and a single `vertical` axis. */
+export declare class RaqmButtonGroupComponent {
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmButtonGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmButtonGroupComponent, "raqm-button-group", never, {
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Decorative divider; `aria-hidden` with no role and no tab stop, vertical by default. */
+export declare class RaqmButtonGroupSeparatorComponent {
+  /** A vertical divider by default; `horizontal` is used inside a vertical group. */
+  readonly horizontal: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmButtonGroupSeparatorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmButtonGroupSeparatorComponent, "raqm-button-group-separator", never, {
+    "horizontal": {
+      "alias": "horizontal";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const RaqmButtonGroup: readonly [typeof RaqmButtonGroupComponent, typeof RaqmButtonGroupSeparatorComponent];

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

@@ -0,0 +1,80 @@
+import * as i0 from "@angular/core";
+type ButtonVariant = 'default' | 'outline' | 'secondary' | 'ghost' | 'destructive' | 'link';
+type ButtonSize = 'xs' | 'sm' | 'default' | 'lg' | 'icon-xs' | 'icon-sm' | 'icon' | 'icon-lg';
+/** Native button/anchor styling, with application-owned content and accessible names. */
+export declare class RaqmButton {
+  private readonly host;
+  protected readonly isAnchor: boolean;
+  private readonly inInputGroup;
+  /** Bare marker uses the default appearance (ghost inside an input group). */
+  readonly appearance: import("@angular/core").InputSignal<"" | ButtonVariant>;
+  readonly extraSmall: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly small: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly large: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly icon: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly iconExtraSmall: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly iconSmall: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly iconLarge: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Native disabled semantics for buttons; equivalent activation blocking for anchors. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Restored when an anchor is re-enabled; accepts static and bound tabindex. */
+  readonly tabIndex: import("@angular/core").InputSignal<string | number | null>;
+  protected readonly activeVariant: import("@angular/core").Signal<ButtonVariant>;
+  /** Size exposed to the shipped styles; input-group members default to xs. */
+  protected readonly activeSize: import("@angular/core").Signal<ButtonSize>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmButton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmButton, "button[raqm-button], a[raqm-button]", never, {
+    "appearance": {
+      "alias": "raqm-button";
+      "required": false;
+      "isSignal": true;
+    };
+    "extraSmall": {
+      "alias": "extra-small";
+      "required": false;
+      "isSignal": true;
+    };
+    "small": {
+      "alias": "small";
+      "required": false;
+      "isSignal": true;
+    };
+    "large": {
+      "alias": "large";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconExtraSmall": {
+      "alias": "icon-extra-small";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconSmall": {
+      "alias": "icon-small";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconLarge": {
+      "alias": "icon-large";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "tabIndex": {
+      "alias": "tabindex";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export {};