@raqm/ui 0.0.0-stage → 0.1.1

package/types/raqm-ui-context-menu.d.ts

@@ -0,0 +1,196 @@
+import * as i0 from "@angular/core";
+import { OnInit, TemplateRef } from "@angular/core";
+import * as i1 from "@raqm/ui/dropdown-menu";
+import * as i2 from "@angular/cdk/menu";
+/** Root popup; the shared menu engine supplies ARIA, focus, typeahead and dismissal. */
+export declare class RaqmContextMenuContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuContentDirective, "[raqm-context-menu-content]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuDirective;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i2.CdkTargetMenuAim;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Semantic group; consumers associate labels using id and aria-labelledby. */
+export declare class RaqmContextMenuGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuGroupDirective, "[raqm-context-menu-group]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuGroupDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Passive group label with optional inset. */
+export declare class RaqmContextMenuLabelDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuLabelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuLabelDirective, "[raqm-context-menu-label]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuLabelDirective;
+    inputs: {
+      "inset": "inset";
+    };
+    outputs: {};
+  }]>;
+}
+/** Menu action with shipped native-anchor guards; disabled/triggered are exposed transitively by CDK. */
+export declare class RaqmContextMenuItemDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuItemDirective, "button[raqm-context-menu-item], a[raqm-context-menu-item]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuItemDirective;
+    inputs: {
+      "inset": "inset";
+      "raqm-menu-item": "raqm-context-menu-item";
+    };
+    outputs: {};
+  }]>;
+}
+/**
+ * Structural submenu boundary; CDK scopes its stack through the submenu trigger/template.
+ *
+ * @remarks
+ * Publishes the family's placement default on an ancestor, so it is available before
+ * the trigger host directive initializes; an application `[positions]` still wins.
+ */
+export declare class RaqmContextMenuSubDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuSubDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuSubDirective, "[raqm-context-menu-sub]", never, {}, {}, never, never, true, never>;
+}
+/** Submenu opener with CDK hover intent and direction-aware arrow navigation/placement. */
+export declare class RaqmContextMenuSubTriggerDirective {
+  readonly template: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  private readonly trigger;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuSubTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuSubTriggerDirective, "button[raqm-context-menu-sub-trigger-for]", never, {
+    "template": {
+      "alias": "raqm-context-menu-sub-trigger-for";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuItemDirective;
+    inputs: {
+      "inset": "inset";
+    };
+    outputs: {};
+  }, {
+    directive: typeof i1.RaqmMenuTriggerDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Nested popup; retains the shared focus/keyboard and hover transit engine. */
+export declare class RaqmContextMenuSubContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuSubContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuSubContentDirective, "[raqm-context-menu-sub-content]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuDirective;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i2.CdkTargetMenuAim;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Keep-open checkbox: the shared checked model, disabled input and checkedChange output. */
+export declare class RaqmContextMenuCheckboxItemDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuCheckboxItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuCheckboxItemDirective, "button[raqm-context-menu-checkbox-item]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuCheckboxItemDirective;
+    inputs: {
+      "inset": "inset";
+      "checked": "checked";
+    };
+    outputs: {
+      "checkedChange": "checkedChange";
+    };
+  }]>;
+}
+/** Exclusive string-value group, reusing the shipped CDK radio scope and value model. */
+export declare class RaqmContextMenuRadioGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuRadioGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuRadioGroupDirective, "[raqm-context-menu-radio-group]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuRadioGroupDirective;
+    inputs: {
+      "value": "value";
+    };
+    outputs: {
+      "valueChange": "valueChange";
+    };
+  }]>;
+}
+/** Keep-open exclusive choice with a trailing check indicator. */
+export declare class RaqmContextMenuRadioItemDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuRadioItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuRadioItemDirective, "button[raqm-context-menu-radio-item]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuRadioItemDirective;
+    inputs: {
+      "value": "value";
+      "inset": "inset";
+    };
+    outputs: {};
+  }]>;
+}
+/** Nonfocusable horizontal separator between action groups. */
+export declare class RaqmContextMenuSeparatorDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuSeparatorDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuSeparatorDirective, "[raqm-context-menu-separator]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuSeparatorDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Display-only keyboard hint; no global accelerator is registered. */
+export declare class RaqmContextMenuShortcutDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuShortcutDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuShortcutDirective, "[raqm-context-menu-shortcut]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuShortcutDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare class RaqmContextMenuTriggerDirective implements OnInit {
+  private readonly trigger;
+  private readonly element;
+  private readonly stack;
+  private readonly destroyRef;
+  private readonly directionality;
+  private readonly overlaySync;
+  private press;
+  private pressTimer;
+  private longPressOpened;
+  private suppressCompatibilityUntil;
+  private readonly guardContextMenu;
+  private readonly guardCompatibilityClick;
+  constructor();
+  /** 500ms stationary press; movement over 10px on either axis cancels it. */
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected cancelLongPress(): void;
+  /** Cursor-side default, with a four-pixel offset and collision fallback. */
+  ngOnInit(): void;
+  private checkHostContract;
+  /** Only opening keys are translated; all menu keys remain owned by the shipped CDK engine. */
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuTriggerDirective, "[raqm-context-menu-trigger-for]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmMenuDirection;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i1.RaqmContextMenuTriggerBase;
+    inputs: {
+      "cdkContextMenuTriggerFor": "raqm-context-menu-trigger-for";
+      "cdkContextMenuPosition": "positions";
+      "cdkContextMenuDisabled": "disabled";
+    };
+    outputs: {
+      "cdkContextMenuOpened": "opened";
+      "cdkContextMenuClosed": "closed";
+    };
+  }]>;
+}
+export declare const RaqmContextMenu: readonly [typeof RaqmContextMenuTriggerDirective, typeof RaqmContextMenuContentDirective, typeof RaqmContextMenuGroupDirective, typeof RaqmContextMenuLabelDirective, typeof RaqmContextMenuItemDirective, typeof RaqmContextMenuSubDirective, typeof RaqmContextMenuSubTriggerDirective, typeof RaqmContextMenuSubContentDirective, typeof RaqmContextMenuCheckboxItemDirective, typeof RaqmContextMenuRadioGroupDirective, typeof RaqmContextMenuRadioItemDirective, typeof RaqmContextMenuSeparatorDirective, typeof RaqmContextMenuShortcutDirective];

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

@@ -0,0 +1,232 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, WritableSignal } from "@angular/core";
+import { OverlayRef, ScrollStrategy, ScrollStrategyOptions } from "@angular/cdk/overlay";
+/** Stable reference to the dialog one registered trigger. */
+interface RaqmDialogTriggerRef {
+  readonly element: HTMLButtonElement;
+  readonly disabled: boolean;
+}
+/** The typed registration contract a dialog root publishes to its descendants. */
+interface RaqmDialogContext {
+  readonly open: Signal<boolean>;
+  readonly dialogId: Signal<string | null>;
+  registerTrigger(ref: RaqmDialogTriggerRef): void;
+  unregisterTrigger(ref: RaqmDialogTriggerRef): void;
+  registerContent(template: TemplateRef<unknown>): void;
+  unregisterContent(template: TemplateRef<unknown>): void;
+  /** Registers a popped title element so the container can point `aria-labelledby` at it. */
+  registerTitle(element: HTMLElement): void;
+  unregisterTitle(element: HTMLElement): void;
+  /** Registers a popped description element so the container can point `aria-describedby` at it. */
+  registerDescription(element: HTMLElement): void;
+  unregisterDescription(element: HTMLElement): void;
+  /** Toggles the dialog from a trigger activation (never opens a disabled root). */
+  toggleFromTrigger(ref: RaqmDialogTriggerRef): void;
+  /** Requests an animated close as a user action (close control / Escape / backdrop). */
+  closeFromUser(): void;
+}
+/** @internal Injection token for the parent dialog root; injected optionally. */
+export declare const RAQM_DIALOG: InjectionToken<RaqmDialogContext>;
+/** @internal Shipped modal-family specialization policy; not application configuration. */
+interface RaqmDialogPolicy {
+  readonly role: 'dialog' | 'alertdialog';
+  readonly contentClass: string;
+  readonly small?: WritableSignal<boolean>;
+  readonly touchOpening: WritableSignal<boolean>;
+  readonly dismissOnBackdrop: boolean;
+  readonly side?: WritableSignal<'top' | 'right' | 'bottom' | 'left'>;
+  readonly paneClass?: string;
+  readonly backdropClass?: string;
+  readonly exitAnimationMs?: number;
+  readonly allowWithoutTrigger?: boolean;
+}
+/** @internal Integration hook for shipped modal families sharing Dialog's lifecycle. */
+export declare const RAQM_DIALOG_POLICY: InjectionToken<RaqmDialogPolicy>;
+/** Application-scoped refcounted document scroll lock shared by all Raqm dialogs. */
+declare class RaqmDialogScrollLock {
+  private readonly strategy;
+  private active;
+  constructor(options: ScrollStrategyOptions);
+  acquire(): void;
+  /** Releases the shared lock; only the last release disables the strategy. */
+  release(): void;
+  /** Creates a per-dialog idempotent lease over the shared lock. */
+  createLease(): ScrollStrategy;
+}
+/** One dialog lease over the shared scroll lock; acquire and release are idempotent. */
+declare class RaqmDialogScrollLease implements ScrollStrategy {
+  private held;
+  private readonly lock;
+  constructor(lock: RaqmDialogScrollLock);
+  /** The CDK attaches the lease to the overlay; the shared lock needs no reference. */
+  attach(_overlayRef: OverlayRef): void;
+  enable(): void;
+  disable(): void;
+  /** Detach is an idempotent alias of {@link disable} for CDK disposal paths. */
+  detach(): void;
+}
+/** @internal Root-scoped token so every dialog root shares one scroll-lock count. */
+declare const RAQM_DIALOG_SCROLL_LOCK: InjectionToken<RaqmDialogScrollLock>;
+/** Modal dialog root shared by Dialog, Alert Dialog, Sheet, Drawer and Command Dialog. */
+export declare abstract class RaqmDialogBaseComponent implements RaqmDialogContext, OnDestroy {
+  protected readonly policy: import("@raqm/ui/dialog").RaqmDialogPolicy | null;
+  private readonly host;
+  private readonly dialogService;
+  private readonly directionality;
+  private readonly renderer;
+  private readonly focusMonitor;
+  private readonly checker;
+  private readonly injector;
+  private readonly scrollLock;
+  private readonly panelTemplate;
+  readonly openValue: import("@angular/core").ModelSignal<boolean>;
+  /** Whether the dialog is disabled; a disabled root never opens. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dir: import("@angular/core").InputSignalWithTransform<"ltr" | "rtl" | undefined, unknown>;
+  readonly panelClass: import("@angular/core").InputSignal<string | undefined>;
+  /** An explicit accessible name used when no title slot is registered. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  protected abstract readonly closeButtonVisible: Signal<boolean>;
+  protected abstract readonly closeLabelText: Signal<string | undefined>;
+  private readonly state;
+  private readonly registration;
+  private readonly canOpen;
+  readonly open: Signal<boolean>;
+  readonly dialogId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly entering: import("@angular/core").WritableSignal<boolean>;
+  protected readonly closing: import("@angular/core").WritableSignal<boolean>;
+  protected readonly panelDir: import("@angular/core").WritableSignal<"ltr" | "rtl">;
+  protected readonly contentTemplate: import("@angular/core").WritableSignal<TemplateRef<unknown> | null>;
+  private readonly overlay;
+  private readonly focus;
+  constructor();
+  ngOnDestroy(): void;
+  registerTrigger(ref: RaqmDialogTriggerRef): void;
+  unregisterTrigger(ref: RaqmDialogTriggerRef): void;
+  registerContent(template: TemplateRef<unknown>): void;
+  unregisterContent(template: TemplateRef<unknown>): void;
+  registerTitle(element: HTMLElement): void;
+  unregisterTitle(element: HTMLElement): void;
+  registerDescription(element: HTMLElement): void;
+  unregisterDescription(element: HTMLElement): void;
+  toggleFromTrigger(ref: RaqmDialogTriggerRef): void;
+  closeFromUser(): void;
+  protected onCloseButtonClick(): void;
+  private readResolvedDir;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogBaseComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmDialogBaseComponent, "raqm-dialog-base", never, {
+    "openValue": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "dir": {
+      "alias": "dir";
+      "required": false;
+      "isSignal": true;
+    };
+    "panelClass": {
+      "alias": "panelClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "openValue": "openChange";
+  }, never, ["*"], true, never>;
+}
+/** Concrete modal root with the optional default close control. */
+export declare class RaqmDialogComponent extends RaqmDialogBaseComponent {
+  readonly showCloseButton: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly closeLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly closeButtonVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly closeLabelText: Signal<string | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmDialogComponent, "raqm-dialog", ["raqmDialog"], {
+    "showCloseButton": {
+      "alias": "showCloseButton";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Directive on the one native button that opens the modal. */
+export declare class RaqmDialogTriggerDirective implements OnInit {
+  private readonly host;
+  private readonly dialog;
+  private readonly destroyRef;
+  readonly open: import("@angular/core").Signal<boolean>;
+  readonly dialogId: import("@angular/core").Signal<string | null>;
+  private readonly ref;
+  constructor();
+  ngOnInit(): void;
+  /** Toggles the modal on a native click; a disabled trigger is a no-op. */
+  protected onClick(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogTriggerDirective, "button[raqm-dialog-trigger]", never, {}, {}, never, never, true, never>;
+}
+/** Content identity only: registers its TemplateRef for the root to render. */
+export declare class RaqmDialogContentDirective implements OnInit {
+  private readonly template;
+  private readonly dialog;
+  private readonly destroyRef;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogContentDirective, "ng-template[raqm-dialog-content]", ["raqmDialogContent"], {}, {}, never, never, true, never>;
+}
+/** Style hook routing an authored close control click to the root animated close. */
+export declare class RaqmDialogCloseDirective {
+  private readonly host;
+  private readonly dialog;
+  constructor();
+  /** Requests the root's single animated close path on click. */
+  protected onClick(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogCloseDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogCloseDirective, "button[raqm-dialog-close]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmDialogHeaderDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogHeaderDirective, "[raqm-dialog-header]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmDialogFooterDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogFooterDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogFooterDirective, "[raqm-dialog-footer]", never, {}, {}, never, never, true, never>;
+}
+/** Registers its host so the container aria-labelledby points at it. */
+export declare class RaqmDialogTitleDirective implements OnInit {
+  private readonly host;
+  private readonly dialog;
+  private readonly destroyRef;
+  constructor();
+  /** Registers the title element with the root once initialized. */
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogTitleDirective, "[raqm-dialog-title]", never, {}, {}, never, never, true, never>;
+}
+/** Registers its host for the container aria-describedby. */
+export declare class RaqmDialogDescriptionDirective implements OnInit {
+  private readonly host;
+  private readonly dialog;
+  private readonly destroyRef;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDialogDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDialogDescriptionDirective, "[raqm-dialog-description]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmDialog: readonly [typeof RaqmDialogComponent, typeof RaqmDialogTriggerDirective, typeof RaqmDialogContentDirective, typeof RaqmDialogCloseDirective, typeof RaqmDialogHeaderDirective, typeof RaqmDialogFooterDirective, typeof RaqmDialogTitleDirective, typeof RaqmDialogDescriptionDirective];
+export type { RaqmDialogPolicy };

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

@@ -0,0 +1,121 @@
+import * as i1 from "@raqm/ui/dialog";
+import { RaqmDialogBaseComponent, RaqmDialogContentDirective, RaqmDialogTriggerDirective } from "@raqm/ui/dialog";
+import * as i0 from "@angular/core";
+type RaqmDrawerDirection = 'down' | 'up' | 'left' | 'right';
+declare class RaqmDrawerSwipeDirective {
+  private readonly surface;
+  private readonly dialog;
+  private readonly dialogRef;
+  private readonly destroyRef;
+  /** The drawer's dismiss direction; it mirrors the surface placement. */
+  readonly direction: import("@angular/core").InputSignal<RaqmDrawerDirection>;
+  private release;
+  private settleTimer;
+  private backdrop;
+  private readonly onPointerDown;
+  constructor();
+  private settle;
+  private hasScrollableAncestor;
+  private resetSurface;
+  private clearSettleTimer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerSwipeDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerSwipeDirective, "[raqm-drawer-swipe]", never, {
+    "direction": {
+      "alias": "direction";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class RaqmDrawerComponent extends RaqmDialogBaseComponent {
+  /** The edge the drawer is attached to; also the direction that dismisses it. */
+  readonly swipeDirection: import("@angular/core").InputSignal<RaqmDrawerDirection>;
+  /** Whether the decorative grab handle is rendered above the content. */
+  readonly showSwipeHandle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Floating presentation: an 8px-inset, rounded, shadowed surface instead of the edge panel. */
+  readonly floating: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Whether the root renders its own close control; opt-in, defaults to `false`. */
+  readonly showCloseButton: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The accessible name of the close control; supplied by the application. */
+  readonly closeLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly closeButtonVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly closeLabelText: import("@angular/core").InputSignal<string | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmDrawerComponent, "raqm-drawer", ["raqmDrawer"], {
+    "swipeDirection": {
+      "alias": "swipeDirection";
+      "required": false;
+      "isSignal": true;
+    };
+    "showSwipeHandle": {
+      "alias": "showSwipeHandle";
+      "required": false;
+      "isSignal": true;
+    };
+    "floating": {
+      "alias": "floating";
+      "required": false;
+      "isSignal": true;
+    };
+    "showCloseButton": {
+      "alias": "showCloseButton";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Native opener reusing Dialog registration and disclosure ARIA; compose raqm-button. */
+export declare class RaqmDrawerTriggerDirective extends RaqmDialogTriggerDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerTriggerDirective, "button[raqm-drawer-trigger]", never, {}, {}, never, never, true, never>;
+}
+/** Native close control using Dialog's single animated user-close path. */
+export declare class RaqmDrawerCloseDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerCloseDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerCloseDirective, "button[raqm-drawer-close]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogCloseDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Portal body template; the root owns placement and the opt-in close control. */
+export declare class RaqmDrawerContentDirective extends RaqmDialogContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerContentDirective, "ng-template[raqm-drawer-content]", ["raqmDrawerContent"], {}, {}, never, never, true, never>;
+}
+/** Passive drawer header, stacking the title and description. */
+export declare class RaqmDrawerHeaderDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerHeaderDirective, "[raqm-drawer-header]", never, {}, {}, never, never, true, never>;
+}
+/** Passive action footer, pushed to the end of the drawer surface. */
+export declare class RaqmDrawerFooterDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerFooterDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerFooterDirective, "[raqm-drawer-footer]", never, {}, {}, never, never, true, never>;
+}
+/** Accessible title registered with the real modal container. */
+export declare class RaqmDrawerTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerTitleDirective, "[raqm-drawer-title]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogTitleDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/** Accessible description registered with the real modal container. */
+export declare class RaqmDrawerDescriptionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmDrawerDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmDrawerDescriptionDirective, "[raqm-drawer-description]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmDialogDescriptionDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare const RaqmDrawer: readonly [typeof RaqmDrawerComponent, typeof RaqmDrawerTriggerDirective, typeof RaqmDrawerCloseDirective, typeof RaqmDrawerContentDirective, typeof RaqmDrawerHeaderDirective, typeof RaqmDrawerFooterDirective, typeof RaqmDrawerTitleDirective, typeof RaqmDrawerDescriptionDirective];
+export type { RaqmDrawerDirection };