@radix-ng/primitives 0.12.1 → 0.13.0

package/README.md

@@ -3,5 +3,7 @@
 > Radix-NG is an unofficial Angular port of [Radix UI](https://www.radix-ui.com/),
 > thus we share the same principal and vision when building primitives.
 
-Radix Primitives is a low-level UI component library with a focus on accessibility, customization and developer experience.
+Radix Primitives is a low-level UI component library with a focus on accessibility,
+customization and developer experience.
+
 You can use these components either as the base layer of your design system, or adopt them incrementally.

package/accordion/index.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/accordion-content.directive";
+import * as i2 from "./src/accordion-header.directive";
+import * as i3 from "./src/accordion-item.directive";
+import * as i4 from "./src/accordion-root.directive";
+import * as i5 from "./src/accordion-trigger.directive";
+export * from './src/accordion-content.directive';
+export * from './src/accordion-header.directive';
+export * from './src/accordion-item.directive';
+export * from './src/accordion-root.directive';
+export * from './src/accordion-trigger.directive';
+export declare class RdxAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxAccordionModule>;
+}

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

@@ -0,0 +1,11 @@
+import { RdxAccordionItemDirective } from './accordion-item.directive';
+import * as i0 from "@angular/core";
+export declare class RdxAccordionContentDirective {
+    protected readonly item: RdxAccordionItemDirective;
+    protected readonly nativeElement: any;
+    protected hidden: boolean;
+    protected onAnimationEnd(): void;
+    onToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", ["rdxAccordionContent"], {}, {}, never, never, true, never>;
+}

package/accordion/src/accordion-header.directive.d.ts

@@ -0,0 +1,7 @@
+import { RdxAccordionItemDirective } from './accordion-item.directive';
+import * as i0 from "@angular/core";
+export declare class RdxAccordionHeaderDirective {
+    protected readonly item: RdxAccordionItemDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,82 @@
+import { FocusableOption } from '@angular/cdk/a11y';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { RdxAccordionContentDirective } from './accordion-content.directive';
+import { RdxAccordionOrientation } from './accordion-root.directive';
+import { RdxAccordionTriggerDirective } from './accordion-trigger.directive';
+import * as i0 from "@angular/core";
+export type RdxAccordionItemState = 'open' | 'closed';
+export declare class RdxAccordionItemDirective implements FocusableOption, OnDestroy {
+    /**
+     * @ignore
+     */
+    protected readonly accordion: import("./accordion-root.directive").RdxAccordionRootDirective;
+    /**
+     * @ignore
+     */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /**
+     * @ignore
+     */
+    protected readonly expansionDispatcher: UniqueSelectionDispatcher;
+    /**
+     * @ignore
+     */
+    trigger: RdxAccordionTriggerDirective;
+    /**
+     * @ignore
+     */
+    content: RdxAccordionContentDirective;
+    get dataState(): RdxAccordionItemState;
+    /**
+     * The unique AccordionItem id.
+     * @ignore
+     */
+    readonly id: string;
+    get orientation(): RdxAccordionOrientation;
+    /** Whether the AccordionItem is expanded. */
+    set expanded(expanded: boolean);
+    get expanded(): boolean;
+    private _expanded;
+    set value(value: string);
+    get value(): string;
+    private _value?;
+    /** Whether the AccordionItem is disabled. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private _disabled;
+    /** Event emitted every time the AccordionItem is closed. */
+    readonly closed: EventEmitter<void>;
+    /** Event emitted every time the AccordionItem is opened. */
+    readonly opened: EventEmitter<void>;
+    /**
+     * Event emitted when the AccordionItem is destroyed.
+     * @ignore
+     */
+    readonly destroyed: EventEmitter<void>;
+    /**
+     * Emits whenever the expanded state of the accordion changes.
+     * Primarily used to facilitate two-way binding.
+     * @docs-private
+     */
+    readonly expandedChange: EventEmitter<boolean>;
+    /** Unregister function for expansionDispatcher. */
+    private removeUniqueSelectionListener;
+    /** Subscription to openAll/closeAll events. */
+    private openCloseAllSubscription;
+    constructor();
+    /** Emits an event for the accordion item being destroyed. */
+    ngOnDestroy(): void;
+    focus(): void;
+    /** Toggles the expanded state of the accordion item. */
+    toggle(): void;
+    /** Sets the expanded state of the accordion item to false. */
+    close(): void;
+    /** Sets the expanded state of the accordion item to true. */
+    open(): void;
+    private subscribeToOpenCloseAllActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "expanded": { "alias": "expanded"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; "expandedChange": "expandedChange"; }, ["trigger", "content"], never, true, never>;
+    static ngAcceptInputType_expanded: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}

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

@@ -0,0 +1,93 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { AfterContentInit, EventEmitter, InjectionToken, OnDestroy, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import { RdxAccordionItemDirective } from './accordion-item.directive';
+import * as i0 from "@angular/core";
+export type RdxAccordionType = 'single' | 'multiple';
+export type RdxAccordionOrientation = 'horizontal' | 'vertical';
+export declare const RdxAccordionRootToken: InjectionToken<RdxAccordionRootDirective>;
+export declare class RdxAccordionRootDirective implements AfterContentInit, OnDestroy {
+    /**
+     * @ignore
+     */
+    protected readonly selectionDispatcher: UniqueSelectionDispatcher;
+    /**
+     * @ignore
+     */
+    protected readonly dir: Directionality | null;
+    /**
+     * @ignore
+     */
+    protected keyManager: FocusKeyManager<RdxAccordionItemDirective>;
+    /**
+     * @ignore
+     */
+    readonly id: string;
+    /**
+     * @ignore
+     */
+    readonly openCloseAllActions: Subject<boolean>;
+    get isMultiple(): boolean;
+    /** Whether the Accordion is disabled. */
+    disabled: boolean;
+    /**
+     * The orientation of the accordion.
+     */
+    orientation: RdxAccordionOrientation;
+    /**
+     * @private
+     * @ignore
+     */
+    items: QueryList<RdxAccordionItemDirective>;
+    /**
+     * The value of the item to expand when initially rendered and type is "single". Use when you do not need to control the state of the items.
+     */
+    set defaultValue(value: string[] | string);
+    get defaultValue(): string[] | string;
+    /**
+     * Determines whether one or multiple items can be opened at the same time.
+     */
+    type: RdxAccordionType;
+    /**
+     * @ignore
+     */
+    collapsible: boolean;
+    /**
+     * The controlled value of the item to expand
+     */
+    set value(value: string[] | string);
+    get value(): string[] | string;
+    readonly onValueChange: EventEmitter<void>;
+    private _value?;
+    private _defaultValue;
+    private onValueChangeSubscription;
+    /**
+     * @ignore
+     */
+    ngAfterContentInit(): void;
+    /**
+     * @ignore
+     */
+    ngOnDestroy(): void;
+    /**
+     * @ignore
+     */
+    handleKeydown(event: KeyboardEvent): void;
+    /** Opens all enabled accordion items in an accordion where multi is enabled.
+     * @ignore
+     */
+    openAll(): void;
+    /** Closes all enabled accordion items.
+     * @ignore
+     */
+    closeAll(): void;
+    /**
+     * @ignore
+     */
+    setActiveItem(item: RdxAccordionItemDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", never, { "disabled": { "alias": "disabled"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "type": { "alias": "type"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onValueChange": "onValueChange"; }, ["items"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}

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

@@ -0,0 +1,15 @@
+import { RdxAccordionItemDirective } from './accordion-item.directive';
+import { RdxAccordionRootDirective } from './accordion-root.directive';
+import * as i0 from "@angular/core";
+export declare class RdxAccordionTriggerDirective {
+    protected readonly nativeElement: any;
+    protected readonly accordionRoot: RdxAccordionRootDirective;
+    protected readonly item: RdxAccordionItemDirective;
+    /**
+     * Fires when trigger clicked
+     */
+    onClick(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
+}

package/alert-dialog/{index.ts → index.d.ts}

@@ -3,5 +3,4 @@ export * from './src/alert-dialog-content.directive';
 export * from './src/alert-dialog-root.directive';
 export * from './src/alert-dialog-title.directive';
 export * from './src/alert-dialog-trigger.directive';
-
 export * from './src/alert-dialog.service';

package/alert-dialog/src/alert-dialog-cancel.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class AlertDialogCancelDirective {
+    private readonly alertDialogService;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogCancelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertDialogCancelDirective, "[rdxAlertDialogCancel]", never, {}, {}, never, never, true, never>;
+}

package/alert-dialog/src/alert-dialog-content.directive.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+export declare class AlertDialogContentDirective {
+    private readonly renderer;
+    private readonly elementRef;
+    set maxWidth(value: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertDialogContentDirective, "[rdxAlertDialogContent]", never, { "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CdkTrapFocus; inputs: {}; outputs: {}; }]>;
+}

package/alert-dialog/src/alert-dialog-root.directive.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AlertDialogRootDirective {
+    private readonly viewContainerRef;
+    private readonly alertDialogService;
+    set content(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertDialogRootDirective, "[rdxAlertDialogRoot]", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+}

package/alert-dialog/src/alert-dialog-title.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class AlertDialogTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertDialogTitleDirective, "[rdxAlertDialogTitle]", never, {}, {}, never, never, true, never>;
+}

package/alert-dialog/src/alert-dialog-trigger.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class AlertDialogTriggerDirective {
+    private readonly alertDialogService;
+    handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AlertDialogTriggerDirective, "[rdxAlertDialogTrigger]", never, {}, {}, never, never, true, never>;
+}

package/alert-dialog/src/alert-dialog.service.d.ts

@@ -0,0 +1,14 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AlertDialogService {
+    private overlay;
+    private overlayRef;
+    private dialogContent;
+    constructor(overlay: Overlay);
+    setDialogContent(viewContainerRef: ViewContainerRef, template: TemplateRef<any>): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertDialogService>;
+}

package/avatar/src/avatar-fallback.directive.d.ts

@@ -0,0 +1,28 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface RdxAvatarFallbackProps {
+    delayMs?: number;
+}
+export declare class RdxAvatarFallbackDirective implements RdxAvatarFallbackProps, OnInit, OnDestroy {
+    private readonly avatar;
+    private readonly config;
+    private readonly ngZone;
+    private readonly platformId;
+    /**
+     * Define a delay before the fallback is shown.
+     * This is useful to only show the fallback for those with slower connections.
+     * @default 0
+     */
+    delayMs: number;
+    protected get visible(): boolean;
+    /**
+     * Determine the delay has elapsed, and we can show the fallback.
+     */
+    private delayElapsed;
+    private timeoutId;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarFallbackDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarFallbackDirective, "span[rdxAvatarFallback]", ["rdxAvatarFallback"], { "delayMs": { "alias": "rdxDelayMs"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_delayMs: unknown;
+}

package/avatar/src/avatar-image.directive.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { RdxImageLoadingStatus } from './avatar-root.directive';
+import * as i0 from "@angular/core";
+export interface RdxAvatarImageProps {
+    onLoadingStatusChange?: EventEmitter<RdxImageLoadingStatus>;
+}
+export declare class RdxAvatarImageDirective implements RdxAvatarImageProps, OnInit {
+    private readonly avatar;
+    private readonly elementRef;
+    /**
+     * By default, it will only render when it has loaded.
+     * You can use the `onLoadingStatusChange` handler if you need more control.
+     */
+    onLoadingStatusChange: EventEmitter<RdxImageLoadingStatus>;
+    ngOnInit(): void;
+    protected onLoad(): void;
+    protected onError(): void;
+    get nativeElement(): HTMLImageElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarImageDirective, "img[rdxAvatarImage]", ["rdxAvatarImage"], {}, { "onLoadingStatusChange": "onLoadingStatusChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+export declare function injectAvatar(): RdxAvatarRootDirective;
+export type RdxImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export declare class RdxAvatarRootDirective {
+    /**
+     * A readonly signal property that holds the current state of image loading.
+     * To set a new status, use the `setState` method of the component.
+     * @internal
+     */
+    readonly _state: import("@angular/core").WritableSignal<RdxImageLoadingStatus>;
+    /**
+     * Set the avatar state.
+     * @param state The new image loading status to set. This value should be one of the predefined states
+     *              in the `ImageLoadingStatus`
+     * @returns void This method does not return a value.
+     * @internal
+     */
+    _setState(state: RdxImageLoadingStatus): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarRootDirective, "span[rdxAvatarRoot]", ["rdxAvatarRoot"], {}, {}, never, never, true, never>;
+}

package/avatar/src/avatar.config.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken, Provider } from '@angular/core';
+export interface RdxAvatarConfig {
+    /**
+     * Define a delay before the fallback is shown.
+     * This is useful to only show the fallback for those with slower connections.
+     * @default 0
+     */
+    delayMs: number;
+}
+export declare const defaultAvatarConfig: RdxAvatarConfig;
+export declare const RdxAvatarConfigToken: InjectionToken<RdxAvatarConfig>;
+export declare function provideRdxAvatarConfig(config: Partial<RdxAvatarConfig>): Provider[];
+export declare function injectAvatarConfig(): RdxAvatarConfig;

package/checkbox/src/checkbox-button.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class RdxCheckboxButtonDirective {
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    readonly id: import("@angular/core").InputSignal<string | null>;
+    protected readonly elementId: import("@angular/core").Signal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxButtonDirective, "button[CheckboxButton]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class RdxCheckboxIndicatorDirective {
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxIndicatorDirective, "[CheckboxIndicator]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class RdxCheckboxInputDirective {
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    readonly id: import("@angular/core").InputSignal<string | undefined>;
+    protected readonly elementId: import("@angular/core").Signal<string | undefined>;
+    protected readonly value: import("@angular/core").Signal<"" | "on" | "off">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxInputDirective, "input[CheckboxInput]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/checkbox/src/checkbox.directive.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export type CheckboxState = 'unchecked' | 'checked' | 'indeterminate';
+export declare class RdxCheckboxDirective implements ControlValueAccessor, OnChanges {
+    /**
+     * The controlled checked state of the checkbox. Must be used in conjunction with onCheckedChange.
+     */
+    checked: boolean;
+    /**
+     * Defines whether the checkbox is indeterminate.
+     */
+    indeterminate: boolean;
+    /**
+     * Defines whether the checkbox is disabled.
+     */
+    disabled: boolean;
+    required: boolean;
+    /**
+     * Event emitted when the checkbox checked state changes.
+     */
+    readonly checkedChange: EventEmitter<boolean>;
+    /**
+     * Event emitted when the indeterminate state changes.
+     */
+    readonly indeterminateChange: EventEmitter<boolean>;
+    /**
+     * Determine the state
+     */
+    get state(): CheckboxState;
+    /**
+     * Store the callback function that should be called when the checkbox checked state changes.
+     * @internal
+     */
+    private onChange?;
+    /**
+     * Store the callback function that should be called when the checkbox is blurred.
+     * @internal
+     */
+    private onTouched?;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onClick($event: MouseEvent): void;
+    protected onBlur(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Sets the checked state of the checkbox.
+     * @param checked The checked state of the checkbox.
+     * @internal
+     */
+    writeValue(checked: boolean): void;
+    /**
+     * Registers a callback function that should be called when the checkbox checked state changes.
+     * @param fn The callback function.
+     * @internal
+     */
+    registerOnChange(fn: (checked: boolean) => void): void;
+    /**
+     * Registers a callback function that should be called when the checkbox is blurred.
+     * @param fn The callback function.
+     * @internal
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Sets the disabled state of the checkbox.
+     * @param isDisabled The disabled state of the checkbox.
+     * @internal
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxDirective, "[CheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, never, true, never>;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}

package/checkbox/src/checkbox.token.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import type { RdxCheckboxDirective } from './checkbox.directive';
+export declare const RdxCheckboxToken: InjectionToken<RdxCheckboxDirective>;
+export declare function injectCheckbox(): RdxCheckboxDirective;

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

@@ -0,0 +1,17 @@
+import { ElementRef } from '@angular/core';
+import { RdxCollapsibleRootDirective } from './collapsible-root.directive';
+import * as i0 from "@angular/core";
+export declare class RdxCollapsibleContentDirective {
+    /**
+     * @ignore
+     */
+    protected readonly collapsible: RdxCollapsibleRootDirective;
+    /**
+     * Reference to CollapsibleContent host element
+     * @ignore
+     */
+    elementRef: ElementRef<HTMLElement>;
+    getDisabled(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentDirective, "[rdxCollapsibleContent]", never, {}, {}, never, never, true, never>;
+}

package/collapsible/src/collapsible-content.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxCollapsibleContentDirective } from './collapsible-content.directive';
+export declare const RdxCollapsibleContentToken: InjectionToken<RdxCollapsibleContentDirective>;

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

@@ -0,0 +1,55 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare function injectCollapsible(): RdxCollapsibleRootDirective;
+export type RdxCollapsibleState = 'open' | 'closed';
+export declare class RdxCollapsibleRootDirective {
+    /**
+     * Reference to RdxCollapsibleContent directive
+     * @private
+     * @ignore
+     */
+    private readonly contentDirective;
+    /**
+     * Stores collapsible state
+     * @private
+     * @ignore
+     */
+    private _open;
+    /**
+     * Determines whether a directive is available for interaction.
+     * When true, prevents the user from interacting with the collapsible.
+     */
+    disabled: boolean;
+    /**
+     * The controlled open state of the collapsible.
+     * Sets the state of the directive. `true` - expanded, `false` - collapsed
+     * @param {boolean} value
+     */
+    set open(value: boolean);
+    /**
+     * Emitted with new value when directive state changed.
+     * Event handler called when the open state of the collapsible changes.
+     */
+    onOpenChange: EventEmitter<boolean>;
+    /**
+     * Allows to change directive state
+     * @param {boolean | undefined} value
+     */
+    setOpen(value?: boolean): void;
+    /**
+     * Returns directive state (open | closed)
+     */
+    getState(): RdxCollapsibleState;
+    /**
+     * Returns current directive state
+     */
+    isOpen(): boolean;
+    /**
+     * Controls visibility of content
+     * @private
+     * @ignore
+     */
+    private setPresence;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleRootDirective, "[rdxCollapsibleRoot]", ["collapsibleRoot"], { "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "onOpenChange": "onOpenChange"; }, ["contentDirective"], never, true, never>;
+}

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

@@ -0,0 +1,26 @@
+import { RdxCollapsibleState } from './collapsible-root.directive';
+import * as i0 from "@angular/core";
+export declare class RdxCollapsibleTriggerDirective {
+    /**
+     * Reference to CollapsibleRoot
+     * @private
+     * @ignore
+     */
+    private readonly collapsible;
+    /**
+     * Called on trigger clicked
+     */
+    onOpenToggle(): void;
+    /**
+     * Returns current directive state (open | closed)
+     * @ignore
+     */
+    getState(): RdxCollapsibleState;
+    /**
+     * Returns current trigger state
+     * @ignore
+     */
+    getDisabled(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleTriggerDirective, "[rdxCollapsibleTrigger]", never, {}, {}, never, never, true, never>;
+}