@radix-ng/primitives 0.12.1 → 0.13.0

package/menubar/src/menubar-item-radio.directive.d.ts

@@ -0,0 +1,14 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+export declare class RdxMenubarItemRadioDirective {
+    private readonly cdkMenuItemRadio;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly disabledState: import("@angular/core").Signal<import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>>;
+    protected readonly checked$: import("@angular/core").WritableSignal<boolean>;
+    protected readonly disabled$: import("@angular/core").WritableSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenubarItemRadioDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenubarItemRadioDirective, "[MenubarItemRadio]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuItemRadio; inputs: {}; outputs: {}; }]>;
+}

package/menubar/src/menubar-item.directive.d.ts

@@ -0,0 +1,8 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/menu";
+export declare class RdxMenuBarItemDirective {
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuBarItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuBarItemDirective, "[MenuBarItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxMenuItemDirective; inputs: { "rdxDisabled": "disabled"; }; outputs: {}; }]>;
+}

package/menubar/src/menubar-radio-group.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+export declare class RdxMenubarRadioGroupDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenubarRadioGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenubarRadioGroupDirective, "[MenubarRadioGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}

package/menubar/src/menubar-root.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+export declare class RdxMenuBarDirective {
+    readonly orientation: import("@angular/core").InputSignal<"horizontal" | "vertical">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuBarDirective, "[MenuBarRoot]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuBar; inputs: {}; outputs: {}; }]>;
+}

package/menubar/src/menubar-separator.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/menu";
+export declare class RdxMenubarSeparatorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenubarSeparatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenubarSeparatorDirective, "[MenubarSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxMenuSeparatorDirective; inputs: {}; outputs: {}; }]>;
+}

package/menubar/src/menubar-trigger.directive.d.ts

@@ -0,0 +1,11 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CdkMenuTrigger } from '@angular/cdk/menu';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+export declare class RdxMenuBarTriggerDirective {
+    protected readonly cdkTrigger: CdkMenuTrigger;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    onPointerDown($event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuBarTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuBarTriggerDirective, "[MenuBarTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "MenuBarTrigger"; }; outputs: {}; }]>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radix-ng/primitives",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -21,9 +21,129 @@
     "@angular/core": "^18.0.0",
     "@angular/cdk": "^18.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
   "sideEffects": false,
-  "scripts": {
-    "compodoc": "compodoc --config .compodocrc.json"
+  "module": "fesm2022/radix-ng-primitives.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/radix-ng-primitives.mjs",
+      "esm": "./esm2022/radix-ng-primitives.mjs",
+      "default": "./fesm2022/radix-ng-primitives.mjs"
+    },
+    "./accordion": {
+      "types": "./accordion/index.d.ts",
+      "esm2022": "./esm2022/accordion/radix-ng-primitives-accordion.mjs",
+      "esm": "./esm2022/accordion/radix-ng-primitives-accordion.mjs",
+      "default": "./fesm2022/radix-ng-primitives-accordion.mjs"
+    },
+    "./alert-dialog": {
+      "types": "./alert-dialog/index.d.ts",
+      "esm2022": "./esm2022/alert-dialog/radix-ng-primitives-alert-dialog.mjs",
+      "esm": "./esm2022/alert-dialog/radix-ng-primitives-alert-dialog.mjs",
+      "default": "./fesm2022/radix-ng-primitives-alert-dialog.mjs"
+    },
+    "./avatar": {
+      "types": "./avatar/index.d.ts",
+      "esm2022": "./esm2022/avatar/radix-ng-primitives-avatar.mjs",
+      "esm": "./esm2022/avatar/radix-ng-primitives-avatar.mjs",
+      "default": "./fesm2022/radix-ng-primitives-avatar.mjs"
+    },
+    "./checkbox": {
+      "types": "./checkbox/index.d.ts",
+      "esm2022": "./esm2022/checkbox/radix-ng-primitives-checkbox.mjs",
+      "esm": "./esm2022/checkbox/radix-ng-primitives-checkbox.mjs",
+      "default": "./fesm2022/radix-ng-primitives-checkbox.mjs"
+    },
+    "./collapsible": {
+      "types": "./collapsible/index.d.ts",
+      "esm2022": "./esm2022/collapsible/radix-ng-primitives-collapsible.mjs",
+      "esm": "./esm2022/collapsible/radix-ng-primitives-collapsible.mjs",
+      "default": "./fesm2022/radix-ng-primitives-collapsible.mjs"
+    },
+    "./context-menu": {
+      "types": "./context-menu/index.d.ts",
+      "esm2022": "./esm2022/context-menu/radix-ng-primitives-context-menu.mjs",
+      "esm": "./esm2022/context-menu/radix-ng-primitives-context-menu.mjs",
+      "default": "./fesm2022/radix-ng-primitives-context-menu.mjs"
+    },
+    "./dialog": {
+      "types": "./dialog/index.d.ts",
+      "esm2022": "./esm2022/dialog/radix-ng-primitives-dialog.mjs",
+      "esm": "./esm2022/dialog/radix-ng-primitives-dialog.mjs",
+      "default": "./fesm2022/radix-ng-primitives-dialog.mjs"
+    },
+    "./dropdown-menu": {
+      "types": "./dropdown-menu/index.d.ts",
+      "esm2022": "./esm2022/dropdown-menu/radix-ng-primitives-dropdown-menu.mjs",
+      "esm": "./esm2022/dropdown-menu/radix-ng-primitives-dropdown-menu.mjs",
+      "default": "./fesm2022/radix-ng-primitives-dropdown-menu.mjs"
+    },
+    "./label": {
+      "types": "./label/index.d.ts",
+      "esm2022": "./esm2022/label/radix-ng-primitives-label.mjs",
+      "esm": "./esm2022/label/radix-ng-primitives-label.mjs",
+      "default": "./fesm2022/radix-ng-primitives-label.mjs"
+    },
+    "./menu": {
+      "types": "./menu/index.d.ts",
+      "esm2022": "./esm2022/menu/radix-ng-primitives-menu.mjs",
+      "esm": "./esm2022/menu/radix-ng-primitives-menu.mjs",
+      "default": "./fesm2022/radix-ng-primitives-menu.mjs"
+    },
+    "./menubar": {
+      "types": "./menubar/index.d.ts",
+      "esm2022": "./esm2022/menubar/radix-ng-primitives-menubar.mjs",
+      "esm": "./esm2022/menubar/radix-ng-primitives-menubar.mjs",
+      "default": "./fesm2022/radix-ng-primitives-menubar.mjs"
+    },
+    "./progress": {
+      "types": "./progress/index.d.ts",
+      "esm2022": "./esm2022/progress/radix-ng-primitives-progress.mjs",
+      "esm": "./esm2022/progress/radix-ng-primitives-progress.mjs",
+      "default": "./fesm2022/radix-ng-primitives-progress.mjs"
+    },
+    "./radio": {
+      "types": "./radio/index.d.ts",
+      "esm2022": "./esm2022/radio/radix-ng-primitives-radio.mjs",
+      "esm": "./esm2022/radio/radix-ng-primitives-radio.mjs",
+      "default": "./fesm2022/radix-ng-primitives-radio.mjs"
+    },
+    "./separator": {
+      "types": "./separator/index.d.ts",
+      "esm2022": "./esm2022/separator/radix-ng-primitives-separator.mjs",
+      "esm": "./esm2022/separator/radix-ng-primitives-separator.mjs",
+      "default": "./fesm2022/radix-ng-primitives-separator.mjs"
+    },
+    "./switch": {
+      "types": "./switch/index.d.ts",
+      "esm2022": "./esm2022/switch/radix-ng-primitives-switch.mjs",
+      "esm": "./esm2022/switch/radix-ng-primitives-switch.mjs",
+      "default": "./fesm2022/radix-ng-primitives-switch.mjs"
+    },
+    "./tabs": {
+      "types": "./tabs/index.d.ts",
+      "esm2022": "./esm2022/tabs/radix-ng-primitives-tabs.mjs",
+      "esm": "./esm2022/tabs/radix-ng-primitives-tabs.mjs",
+      "default": "./fesm2022/radix-ng-primitives-tabs.mjs"
+    },
+    "./toggle": {
+      "types": "./toggle/index.d.ts",
+      "esm2022": "./esm2022/toggle/radix-ng-primitives-toggle.mjs",
+      "esm": "./esm2022/toggle/radix-ng-primitives-toggle.mjs",
+      "default": "./fesm2022/radix-ng-primitives-toggle.mjs"
+    },
+    "./toggle-group": {
+      "types": "./toggle-group/index.d.ts",
+      "esm2022": "./esm2022/toggle-group/radix-ng-primitives-toggle-group.mjs",
+      "esm": "./esm2022/toggle-group/radix-ng-primitives-toggle-group.mjs",
+      "default": "./fesm2022/radix-ng-primitives-toggle-group.mjs"
+    }
   }
 }

package/progress/index.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/progress-root.directive";
+import * as i2 from "./src/progress-indicator.directive";
+export * from './src/progress-indicator.directive';
+export * from './src/progress-root.directive';
+export type { ProgressProps } from './src/progress-root.directive';
+export declare class RdxProgressModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxProgressModule, never, [typeof i1.RdxProgressRootDirective, typeof i2.RdxProgressIndicatorDirective], [typeof i1.RdxProgressRootDirective, typeof i2.RdxProgressIndicatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxProgressModule>;
+}

package/progress/src/progress-indicator.directive.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+/**
+ * Directive to manage progress indicator state and attributes.
+ *
+ * This directive is used to display the progress indicator inside the progress bar.
+ * It inherits the state and value from the `RdxProgressRootDirective`.
+ */
+export declare class RdxProgressIndicatorDirective {
+    /**
+     *
+     * This allows the directive to access the progress bar state and values.
+     */
+    protected readonly progress: import("./progress-root.directive").RdxProgressRootDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressIndicatorDirective, "[rdxProgressIndicator]", ["rdxProgressIndicator"], {}, {}, never, never, true, never>;
+}

package/progress/src/progress-root.directive.d.ts

@@ -0,0 +1,63 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Injects the current instance of RdxProgressRootDirective.
+ * @returns The instance of RdxProgressRootDirective.
+ */
+export declare function injectProgress(): RdxProgressRootDirective;
+export type ProgressState = 'indeterminate' | 'complete' | 'loading';
+export interface ProgressProps {
+    value?: number | null | undefined;
+    max?: number;
+    getValueLabel?: string;
+}
+/**
+ * Directive to manage progress bar state and attributes.
+ *
+ * This directive provides a way to create a progress bar with customizable value and max attributes.
+ * It handles aria attributes for accessibility and provides different states like 'indeterminate', 'complete', and 'loading'.
+ */
+export declare class RdxProgressRootDirective implements ProgressProps, OnChanges {
+    /**
+     * The unique ID for the progress bar.
+     * @default 'rdx-progress-bar-{idIterator}'
+     */
+    id: string;
+    /**
+     * The current value of the progress bar.
+     * @default 0
+     */
+    value: number;
+    /**
+     * The maximum value of the progress bar.
+     * @default 100
+     */
+    max: number;
+    /**
+     * Function to generate the value label.
+     */
+    valueLabel: (value: number, max: number) => string;
+    /**
+     * Lifecycle hook that is called when any data-bound property of a directive changes.
+     * @param changes - The changed properties.
+     * @ignore
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Get the state of the progress bar.
+     * @returns 'indeterminate' | 'loading' | 'complete'
+     * @ignore
+     */
+    get state(): ProgressState;
+    private getProgressState;
+    private defaultGetValueLabel;
+    private isValidMaxNumber;
+    private isNumber;
+    private isValidValueNumber;
+    private getInvalidMaxError;
+    private getInvalidValueError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressRootDirective, "[rdxProgressRoot]", ["rdxProgressRoot"], { "id": { "alias": "id"; "required": false; }; "value": { "alias": "rdxValue"; "required": false; }; "max": { "alias": "rdxMax"; "required": false; }; "valueLabel": { "alias": "rdxValueLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_value: unknown;
+    static ngAcceptInputType_max: unknown;
+}

package/radio/{index.ts → index.d.ts}

@@ -1,4 +1,3 @@
 export * from './src/radio-root.directive';
-
 export * from './src/radio-indicator.directive';
 export * from './src/radio-item.directive';

package/radio/src/radio-indicator.directive.d.ts

@@ -0,0 +1,9 @@
+import { RdxRadioItemDirective } from './radio-item.directive';
+import { RadioGroupDirective } from './radio-tokens';
+import * as i0 from "@angular/core";
+export declare class RdxRadioIndicatorDirective {
+    protected readonly radioGroup: RadioGroupDirective;
+    protected readonly radioItem: RdxRadioItemDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxRadioIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxRadioIndicatorDirective, "[rdxRadioIndicator]", ["rdxRadioIndicator"], {}, {}, never, never, true, never>;
+}

package/radio/src/radio-item.directive.d.ts

@@ -0,0 +1,21 @@
+import { FocusableOption } from '@angular/cdk/a11y';
+import { ElementRef, InjectionToken, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const RdxRadioItemToken: InjectionToken<RdxRadioItemDirective>;
+export declare function injectRadioItem(): RdxRadioItemDirective;
+export declare class RdxRadioItemDirective implements FocusableOption, OnInit {
+    private readonly radioGroup;
+    readonly element: ElementRef<any>;
+    id: string;
+    value: string;
+    disabled: boolean;
+    get tabIndex(): number;
+    get checked(): boolean;
+    ngOnInit(): void;
+    focus(): void;
+    _onClick(): void;
+    _onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxRadioItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxRadioItemDirective, "[rdxRadioItem]", ["rdxRadioItem"], { "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}

package/radio/src/radio-root.directive.d.ts

@@ -0,0 +1,72 @@
+import { AfterContentInit, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { RdxRadioItemDirective } from './radio-item.directive';
+import { RadioGroupDirective, RadioGroupProps } from './radio-tokens';
+import * as i0 from "@angular/core";
+export declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor, AfterContentInit, OnDestroy {
+    radioItems: QueryList<RdxRadioItemDirective>;
+    private focusKeyManager;
+    private destroy$;
+    name?: string | undefined;
+    value?: string;
+    disabled: boolean;
+    dir?: string;
+    defaultValue?: string;
+    /**
+     * The orientation of the radio group only vertical.
+     * Horizontal radio buttons can sometimes be challenging to scan and localize.
+     * The horizontal arrangement of radio buttons may also lead to difficulties in determining which
+     * label corresponds to which button: whether the label is above or below the button.
+     * @default 'vertical'
+     */
+    readonly _orientation = "vertical";
+    /**
+     * Event handler called when the value changes.
+     */
+    readonly onValueChange: EventEmitter<string>;
+    /**
+     * The callback function to call when the value of the radio group changes.
+     */
+    private onChange;
+    /**
+     * The callback function to call when the radio group is touched.
+     */
+    onTouched: () => void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Select a radio item.
+     * @param value The value of the radio item to select.
+     */
+    select(value: string): void;
+    /**
+     * Update the value of the radio group.
+     * @param value The new value of the radio group.
+     * @internal
+     */
+    writeValue(value: string): void;
+    /**
+     * Register a callback function to call when the value of the radio group changes.
+     * @param fn The callback function to call when the value of the radio group changes.
+     * @internal
+     */
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Set the disabled state of the radio group.
+     * @param isDisabled Whether the radio group is disabled.
+     * @internal
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * When focus leaves the radio group.
+     */
+    _onFocusin(event: FocusEvent): void;
+    _onKeydown(event: KeyboardEvent): void;
+    private selectFocusedItem;
+    private updateActiveItem;
+    private tabNavigation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxRadioGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxRadioGroupDirective, "[rdxRadioRoot]", ["rdxRadioRoot"], { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; }, { "onValueChange": "onValueChange"; }, ["radioItems"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}

package/radio/src/{radio-tokens.ts → radio-tokens.d.ts}

@@ -1,16 +1,12 @@
 import { InjectionToken } from '@angular/core';
-
 export interface RadioGroupProps {
     name?: string;
     disabled?: boolean;
     defaultValue?: string;
     value?: string;
 }
-
 export interface RadioGroupDirective extends RadioGroupProps {
     select(value: string): void;
-
     onTouched(): void;
 }
-
-export const RDX_RADIO_GROUP = new InjectionToken<RadioGroupDirective>('RdxRadioGroup');
+export declare const RDX_RADIO_GROUP: InjectionToken<RadioGroupDirective>;

package/separator/src/separator.directive.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+export type Orientation = (typeof ORIENTATIONS)[number];
+export interface SeparatorProps {
+    /**
+     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
+     */
+    orientation?: Orientation;
+    /**
+     * Whether the component is purely decorative. When true, accessibility-related attributes
+     * are updated so that the rendered element is removed from the accessibility tree.
+     */
+    decorative?: boolean;
+}
+export declare class RdxSeparatorRootDirective implements SeparatorProps {
+    orientation: Orientation;
+    decorative: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSeparatorRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSeparatorRootDirective, "div[rdxSeparatorRoot]", never, { "orientation": { "alias": "orientation"; "required": false; }; "decorative": { "alias": "decorative"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_decorative: unknown;
+}
+export {};

package/switch/index.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/switch-root.directive";
+import * as i2 from "./src/switch-input.directive";
+import * as i3 from "./src/switch-thumb.directive";
+export * from './src/switch-input.directive';
+export * from './src/switch-root.directive';
+export * from './src/switch-thumb.directive';
+export type { SwitchProps } from './src/switch-root.directive';
+export declare class RdxSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSwitchModule, never, [typeof i1.RdxSwitchRootDirective, typeof i2.RdxSwitchInputDirective, typeof i3.RdxSwitchThumbDirective], [typeof i1.RdxSwitchRootDirective, typeof i2.RdxSwitchInputDirective, typeof i3.RdxSwitchThumbDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxSwitchModule>;
+}

package/switch/src/switch-input.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class RdxSwitchInputDirective {
+    protected readonly switchRoot: import("./switch-root.directive").RdxSwitchRootDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchInputDirective, "input[rdxSwitchInput]", ["rdxSwitchInput"], {}, {}, never, never, true, never>;
+}

package/switch/src/switch-root.directive.d.ts

@@ -0,0 +1,51 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { EventEmitter, InjectionToken, InputSignalWithTransform, ModelSignal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const RdxSwitchToken: InjectionToken<RdxSwitchRootDirective>;
+export declare function injectSwitch(): RdxSwitchRootDirective;
+export interface SwitchProps {
+    checked?: ModelSignal<boolean>;
+    defaultChecked?: boolean;
+    required?: InputSignalWithTransform<boolean, BooleanInput>;
+    onCheckedChange?: EventEmitter<boolean>;
+}
+export declare class RdxSwitchRootDirective implements SwitchProps, ControlValueAccessor {
+    readonly id: import("@angular/core").InputSignal<string>;
+    protected readonly elementId: import("@angular/core").Signal<string | null>;
+    readonly required: InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: ModelSignal<boolean>;
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabledState: import("@angular/core").Signal<boolean>;
+    onCheckedChange: EventEmitter<boolean>;
+    /**
+     * The method to be called in order to update ngModel.
+     */
+    _onChange?: (checked: boolean) => void;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     */
+    _onTouched?: () => void;
+    /**
+     * Registers a function to call when the checked state changes.
+     * @param fn Function to call on change.
+     */
+    registerOnChange(fn: (checked: boolean) => void): void;
+    /**
+     * Registers a function to call when the component is touched.
+     * @param fn Function to call on touch.
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Writes a new value to the model.
+     * @param checked The new checked value.
+     */
+    writeValue(checked: boolean): void;
+    /**
+     * Toggles the checked state of the switch.
+     * If the switch is disabled, the function returns early.
+     */
+    protected toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchRootDirective, "button[rdxSwitchRoot]", ["rdxSwitchRoot"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "onCheckedChange": "onCheckedChange"; }, never, never, true, never>;
+}

package/switch/src/switch-thumb.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class RdxSwitchThumbDirective {
+    protected readonly switchRoot: import("./switch-root.directive").RdxSwitchRootDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchThumbDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchThumbDirective, "span[rdxSwitchThumb]", ["rdxSwitchThumb"], {}, {}, never, never, true, never>;
+}

package/tabs/index.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/tabs-root.directive";
+import * as i2 from "./src/tabs-content.directive";
+import * as i3 from "./src/tabs-list.directive";
+import * as i4 from "./src/tabs-trigger.directive";
+export * from './src/tabs-content.directive';
+export * from './src/tabs-context.service';
+export * from './src/tabs-list.directive';
+export * from './src/tabs-root.directive';
+export * from './src/tabs-trigger.directive';
+export declare class RdxTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTabsModule, never, [typeof i1.RdxTabsRootDirective, typeof i2.RdxTabsContentDirective, typeof i3.RdxTabsListDirective, typeof i4.RdxTabsTriggerDirective], [typeof i1.RdxTabsRootDirective, typeof i2.RdxTabsContentDirective, typeof i3.RdxTabsListDirective, typeof i4.RdxTabsTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxTabsModule>;
+}

package/tabs/src/tabs-content.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class RdxTabsContentDirective {
+    protected readonly tabsContext: import("./tabs-context.service").RdxTabsContextService;
+    readonly value: import("@angular/core").InputSignal<string>;
+    protected readonly selected: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTabsContentDirective, "[rdxTabsContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tabs/src/tabs-context.service.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const TABS_CONTEXT_TOKEN: InjectionToken<RdxTabsContextService>;
+export declare class RdxTabsContextService {
+    private baseId;
+    private value;
+    private orientation;
+    private dir;
+    private activationMode;
+    readonly value$: import("@angular/core").Signal<string | undefined>;
+    readonly orientation$: import("@angular/core").Signal<string>;
+    readonly dir$: import("@angular/core").Signal<string | undefined>;
+    readonly activationMode$: import("@angular/core").Signal<string>;
+    setValue(value: string): void;
+    setOrientation(orientation: string): void;
+    setDir(dir: string): void;
+    setActivationMode(mode: string): void;
+    getBaseId(): string;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxTabsContextService>;
+}

package/tabs/src/tabs-list.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class RdxTabsListDirective {
+    protected readonly tabsContext: import("./tabs-context.service").RdxTabsContextService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTabsListDirective, "[rdxTabsList]", never, {}, {}, never, never, true, never>;
+}

package/tabs/src/tabs-root.directive.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface TabsProps {
+    /** The value for the selected tab, if controlled */
+    value?: string;
+    /** The value of the tab to select by default, if uncontrolled */
+    defaultValue?: string;
+    /** A function called when a new tab is selected */
+    onValueChange?: (value: string) => void;
+    /**
+     * The orientation the tabs are layed out.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     * @defaultValue horizontal
+     */
+    orientation?: string;
+    /**
+     * The direction of navigation between toolbar items.
+     */
+    dir?: string;
+    /**
+     * Whether a tab is activated automatically or manually.
+     * @defaultValue automatic
+     * */
+    activationMode?: 'automatic' | 'manual';
+}
+export declare class RdxTabsRootDirective implements OnInit {
+    private readonly tabsContext;
+    value?: string;
+    defaultValue?: string;
+    orientation: string;
+    dir?: string;
+    onValueChange: EventEmitter<string>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTabsRootDirective, "[rdxTabsRoot]", never, { "value": { "alias": "value"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; }, { "onValueChange": "onValueChange"; }, never, never, true, never>;
+}