import * as _angular_core from '@angular/core'; import { InjectionToken, WritableSignal, Signal, OnInit, OnDestroy, ElementRef } from '@angular/core'; import { FormValueControl, WithOptionalFieldTree, ValidationError, FormCheckboxControl } from '@angular/forms/signals'; import { FocusableOption } from '@angular/cdk/a11y'; import * as _atelier_ui_angular from '@atelier-ui/angular'; import * as i1 from '@angular/cdk/accordion'; import * as i1$1 from '@angular/cdk/menu'; /** * @atelier-ui/spec * * Framework-agnostic TypeScript interfaces defining the public API contract * for every Atelier component. Both the Angular and React libraries * import from here so the compiler enforces parity. * * Angular: use the union types as `input()` type parameters. * React: extend the spec interface from the framework-specific props interface. */ type AtlButtonVariant = 'primary' | 'secondary' | 'outline' | 'danger'; type AtlButtonSize = 'sm' | 'md' | 'lg'; interface AtlComboboxOption { value: string; label: string; disabled?: boolean; } type AtlIconName = 'success' | 'warning' | 'danger' | 'info' | 'error' | 'chevron-up' | 'chevron-down' | 'chevron-left' | 'chevron-right' | 'sort-asc' | 'sort-desc' | 'arrow-right' | 'arrow-left' | 'copy' | 'paste' | 'add' | 'edit' | 'delete' | 'close' | 'more' | 'default-toast'; type AtlIconSize = 'sm' | 'md' | 'lg'; type AtlChatVariant = 'drawer' | 'popup' | 'inline'; type AtlChatStatus = 'idle' | 'streaming' | 'error'; type AtlChatMessageRole = 'user' | 'assistant' | 'system'; /** * Accessible button component with visual variants and sizes. * * Usage: * ```html * Save * Cancel * Saving… * ``` */ declare class AtlButton { /** Visual style of the button. */ readonly variant: _angular_core.InputSignal; /** Size of the button. */ readonly size: _angular_core.InputSignal; /** Disables the button, preventing interaction. */ readonly disabled: _angular_core.InputSignal; /** Shows a loading spinner and disables interaction. */ readonly loading: _angular_core.InputSignal; protected readonly isDisabled: _angular_core.Signal; protected readonly hostClasses: _angular_core.Signal; /** @internal — host element ref for the dev-mode a11y check. */ private readonly el; private readonly destroyRef; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Card container component supporting elevated, outlined, and flat visual variants. * Compose with `atl-card-header`, `atl-card-content`, and `atl-card-footer` sub-components. * * Usage: * ```html * * Card Title * Main content goes here. * * Save * * * ``` */ declare class AtlCard { /** Visual style of the card. */ readonly variant: _angular_core.InputSignal<"elevated" | "outlined" | "flat">; /** Internal padding of the card. */ readonly padding: _angular_core.InputSignal<"sm" | "md" | "lg" | "none">; /** * Opt-in landmark role. Default is no role. * * - `'article'` — self-contained content (blog post, comment). * - `'region'` — perceivable area that needs a screen-reader stop; * pair with `aria-label`. * - `'section'` — mirrors an HTML `
`. * * Most cards group content visually and shouldn't add a landmark. * Leave unset by default. */ readonly role: _angular_core.InputSignal<"article" | "region" | "section" | undefined>; protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Header slot for `atl-card`. Renders above the main content with a bottom separator. * * Usage: * ```html * Card Title * ``` */ declare class AtlCardHeader { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Content slot for `atl-card`. Primary content area of the card. * * Usage: * ```html * Body text here. * ``` */ declare class AtlCardContent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Footer slot for `atl-card`. Renders below the main content, typically holds actions. * * Usage: * ```html * * Save * * ``` */ declare class AtlCardFooter { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class AtlBadge { /** Semantic color variant of the badge. */ readonly variant: _angular_core.InputSignal<"danger" | "default" | "success" | "warning" | "info">; /** Size of the badge. */ readonly size: _angular_core.InputSignal<"sm" | "md">; protected readonly hostClasses: _angular_core.Signal; protected readonly variantIcon: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Pictogram glyph icon. 21 named variants matching the Figma `AtlIcon` * component set. Decorative by default; pass `label` to announce a meaning * to assistive tech. * * Usage: * ```html * * * ``` */ declare class AtlIcon { readonly name: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; protected readonly glyph: _angular_core.Signal; protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible text input component for use with Angular Signal Forms. * * Usage: * ```html * * * ``` */ declare class AtlInput implements FormValueControl { /** The current input value. Bound by [formField] directive. Supports [(value)] two-way binding. */ readonly value: _angular_core.ModelSignal; /** The type of input field. */ readonly type: _angular_core.InputSignal<"number" | "text" | "email" | "password" | "tel" | "url">; /** Placeholder text shown when the input is empty. */ readonly placeholder: _angular_core.InputSignal; /** Whether the input is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the input is read-only. Bound by [formField] directive. */ readonly readonly: _angular_core.InputSignal; /** Whether the input has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** Whether the user has interacted with the input. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Whether the input is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** The input's name attribute. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** @internal */ protected readonly errorId: string; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal */ protected onInput(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible multiline text input component for use with Angular Signal Forms. * * Usage: * ```html * * * ``` */ declare class AtlTextarea implements FormValueControl { /** The current textarea value. Supports [(value)] two-way binding. */ readonly value: _angular_core.ModelSignal; /** Number of visible text rows. */ readonly rows: _angular_core.InputSignal; /** Placeholder text shown when the textarea is empty. */ readonly placeholder: _angular_core.InputSignal; /** Whether the textarea is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the textarea is read-only. Bound by [formField] directive. */ readonly readonly: _angular_core.InputSignal; /** Whether the textarea has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** Whether the user has interacted with the textarea. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Whether the textarea is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** The textarea's name attribute. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** Whether to auto-resize the textarea height to fit its content. */ readonly autoResize: _angular_core.InputSignal; /** @internal */ protected readonly errorId: string; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal */ protected onInput(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible checkbox component for use with Angular Signal Forms. * * Usage: * ```html * I agree to the terms * Accept * ``` */ declare class AtlCheckbox implements FormCheckboxControl { /** The checked state. Bound by [formField] directive. Supports [(checked)] two-way binding. */ readonly checked: _angular_core.ModelSignal; /** Whether the user has interacted with the input. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Tri-state indeterminate mode (e.g. "select all"). Set via DOM property. */ readonly indeterminate: _angular_core.InputSignal; /** Whether the checkbox is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the checkbox has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Whether the checkbox is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** The input's name attribute. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** @internal */ protected readonly inputId: string; /** @internal */ protected readonly errorId: string; /** @internal */ private readonly nativeInput; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; constructor(); /** @internal */ protected onChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** @internal — shape required by AtlRadioGroup's FocusKeyManager */ interface RadioItem extends FocusableOption { focus(): void; disabled?: boolean; readonly radioValue: Signal; } interface AtlRadioGroupContext { readonly value: WritableSignal; readonly name: Signal; readonly disabled: Signal; select(v: string): void; markTouched(): void; registerItem(item: RadioItem): void; unregisterItem(item: RadioItem): void; } declare const ATL_RADIO_GROUP: InjectionToken; /** * Individual radio button. Must be placed inside an `atl-radio-group`. * * Usage: * ```html * * Free * Pro * * ``` */ declare class AtlRadio implements RadioItem, OnInit, OnDestroy { /** The value this radio option represents within the group. */ readonly radioValue: _angular_core.InputSignal; /** Whether this specific radio is individually disabled (stacked with group disabled). */ readonly disabledInput: _angular_core.InputSignal; /** @internal */ private readonly group; /** @internal */ private readonly el; /** @internal */ protected readonly inputId: string; /** @internal */ protected readonly isChecked: _angular_core.Signal; /** @internal */ readonly isDisabled: _angular_core.Signal; /** @internal */ protected readonly effectiveName: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal — for FocusKeyManager */ get disabled(): boolean; /** @internal — for FocusKeyManager */ focus(): void; ngOnInit(): void; ngOnDestroy(): void; /** @internal */ protected onChange(): void; /** @internal */ protected onBlur(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Container for a group of radio buttons. Manages keyboard navigation, shared name, * and Signal Forms integration. * * Usage: * ```html * * Small * Medium * Large * * * * * Small * * ``` */ declare class AtlRadioGroup implements FormValueControl, AtlRadioGroupContext { /** The selected value. Bound by [formField] directive. Supports [(value)] two-way binding. */ readonly value: _angular_core.ModelSignal; /** Whether the user has interacted. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Whether the group is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the group has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Whether the group is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** Shared name attribute propagated to all child radio inputs. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** @internal */ protected readonly errorId: string; /** @internal */ private readonly items; /** @internal */ private keyManager; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal — called by AtlRadio on change */ select(v: string): void; /** @internal — called by AtlRadio on blur */ markTouched(): void; /** @internal — called by AtlRadio on init */ registerItem(item: RadioItem): void; /** @internal — called by AtlRadio on destroy */ unregisterItem(item: RadioItem): void; /** @internal */ protected onKeydown(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible toggle (switch) component for use with Angular Signal Forms. * Presents as a pill-shaped on/off slider instead of a checkbox box, * but has identical boolean semantics and implements FormCheckboxControl. * * Usage: * ```html * Enable notifications * Enable * ``` */ declare class AtlToggle implements FormCheckboxControl { /** The checked state. Bound by [formField] directive. Supports [(checked)] two-way binding. */ readonly checked: _angular_core.ModelSignal; /** Whether the user has interacted with the input. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Whether the toggle is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the toggle has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Whether the toggle is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** The input's name attribute. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** @internal */ protected readonly inputId: string; /** @internal */ protected readonly errorId: string; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal */ protected onChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class AtlAlert { /** Semantic color variant of the alert. */ readonly variant: _angular_core.InputSignal<"danger" | "success" | "warning" | "info">; /** Whether to show a dismiss button. */ readonly dismissible: _angular_core.InputSignal; /** Emitted when the dismiss button is clicked. */ readonly dismissed: _angular_core.OutputEmitterRef; protected readonly hostClasses: _angular_core.Signal; protected readonly variantIcon: _angular_core.Signal; /** @internal */ get isDismissible(): boolean; /** @internal */ get hostClassesValue(): string; /** @internal */ get ariaLive(): string; protected dismiss(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface AtlSelectContext { readonly value: WritableSignal; readonly disabled: Signal; readonly activeOptionId: WritableSignal; select(v: string): void; markTouched(): void; registerOption(id: string, value: string, labelText: string, disabled: boolean): void; unregisterOption(id: string): void; } declare const ATL_SELECT: InjectionToken; /** * Accessible dropdown select component for use with Angular Signal Forms. * Uses the CDK Overlay for viewport-aware panel positioning. * * Usage: * ```html * * United States * Canada * * * * * United States * * ``` */ declare class AtlSelect implements FormValueControl, AtlSelectContext, OnDestroy { /** The selected value. Bound by [formField] directive. Supports [(value)] two-way binding. */ readonly value: _angular_core.ModelSignal; /** Whether the user has interacted. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Placeholder text shown when no option is selected. */ readonly placeholder: _angular_core.InputSignal; /** Whether the select is disabled. Bound by [formField] directive. */ readonly disabled: _angular_core.InputSignal; /** Whether the select has validation errors. Bound by [formField] directive. */ readonly invalid: _angular_core.InputSignal; /** Whether the select is required. Bound by [formField] directive. */ readonly required: _angular_core.InputSignal; /** The input's name attribute. Bound by [formField] directive. */ readonly name: _angular_core.InputSignal; /** Validation errors from the form system. Bound by [formField] directive. */ readonly errors: _angular_core.InputSignal[]>; /** @internal */ readonly activeOptionId: _angular_core.WritableSignal; /** @internal */ protected readonly isOpen: _angular_core.WritableSignal; /** @internal */ protected readonly optionsList: _angular_core.WritableSignal<{ id: string; value: string; labelText: string; disabled: boolean; }[]>; /** @internal */ protected readonly panelRef: _angular_core.Signal | undefined>; /** @internal */ protected readonly triggerId: string; /** @internal */ protected readonly panelId: string; /** @internal */ protected readonly errorId: string; /** @internal */ protected readonly selectedLabel: _angular_core.Signal; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal */ private keyManager; private overlayRef; private outsideClickHandler; private readonly elementRef; private readonly injector; /** @internal — called by AtlOption on init */ registerOption(id: string, value: string, labelText: string, disabled: boolean): void; /** @internal — called by AtlOption on destroy */ unregisterOption(id: string): void; /** @internal — called by AtlOption on select */ select(v: string): void; /** @internal — called by AtlOption on interaction */ markTouched(): void; /** @internal */ protected onTriggerClick(): void; /** @internal */ protected onTriggerBlur(): void; /** @internal */ protected onKeydown(event: KeyboardEvent): void; ngOnDestroy(): void; private open; private close; private createOverlay; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Option item for use inside ``. * * Usage: * ```html * United States * ``` */ declare class AtlOption implements OnInit, OnDestroy { /** The value this option represents. Required. */ readonly optionValue: _angular_core.InputSignal; /** Whether this option is disabled. */ readonly disabled: _angular_core.InputSignal; /** @internal */ protected readonly optionId: string; /** @internal */ private readonly context; /** @internal */ private readonly elementRef; /** @internal */ protected readonly isSelected: _angular_core.Signal; /** @internal */ protected readonly isActive: _angular_core.Signal; ngOnInit(): void; ngOnDestroy(): void; /** @internal */ protected onClick(): void; /** @internal */ protected onMouseEnter(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Filterable autocomplete combobox. Accepts an `options` array and emits the * selected option's `value`. The user types to narrow the list; selecting an * option commits the value and displays its label. * * Usage: * ```html * * * * * ``` */ declare class AtlCombobox implements FormValueControl { /** The selected value. Supports [(value)] two-way binding and [formField] directive. */ readonly value: _angular_core.ModelSignal; /** Whether the user has interacted. Bound by [formField] directive. */ readonly touched: _angular_core.ModelSignal; /** Options to display and filter. */ readonly options: _angular_core.InputSignal; /** Placeholder text for the input. */ readonly placeholder: _angular_core.InputSignal; /** Whether the combobox is disabled. */ readonly disabled: _angular_core.InputSignal; /** Whether the combobox has validation errors. */ readonly invalid: _angular_core.InputSignal; /** Whether the combobox is required. */ readonly required: _angular_core.InputSignal; /** The input's name attribute. */ readonly name: _angular_core.InputSignal; /** Validation errors from the form system. */ readonly errors: _angular_core.InputSignal[]>; /** @internal */ protected readonly query: _angular_core.WritableSignal; /** @internal */ protected readonly isOpen: _angular_core.WritableSignal; /** @internal */ protected readonly activeIndex: _angular_core.WritableSignal; /** @internal */ protected readonly panelRef: _angular_core.Signal | undefined>; /** @internal */ protected readonly inputEl: _angular_core.Signal | undefined>; /** @internal */ protected readonly inputId: string; /** @internal */ protected readonly panelId: string; /** @internal */ protected readonly errorId: string; /** @internal */ protected readonly filteredOptions: _angular_core.Signal; /** @internal */ protected readonly activeOptionId: _angular_core.Signal; /** @internal */ protected readonly showErrors: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; private outsideClickHandler; private readonly elementRef; /** @internal */ protected optionId(index: number): string; /** @internal */ protected onInput(event: Event): void; /** @internal */ protected onFocus(): void; /** @internal */ protected onBlur(): void; /** @internal */ protected onOptionSelect(option: AtlComboboxOption): void; /** @internal */ protected onKeydown(event: KeyboardEvent): void; private open; private close; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible modal dialog using the native `` element. * Includes focus trap, Escape to close, backdrop click to close, and animation. * Compose with `atl-dialog-header`, `atl-dialog-content`, and `atl-dialog-footer`. * * Usage: * ```html * * Dialog Title * Dialog body content. * * Confirm * * * ``` */ declare class AtlDialog { /** Whether the dialog is open. Supports two-way binding: [(open)]="isOpen". */ readonly open: _angular_core.ModelSignal; /** Whether clicking the backdrop closes the dialog. */ readonly closeOnBackdrop: _angular_core.InputSignal; /** Size of the dialog panel. */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "full">; /** Accessible label for the dialog (use instead of aria-labelledby when no header is present). */ readonly ariaLabel: _angular_core.InputSignal; /** ID of the element that labels the dialog (defaults to the atl-dialog-header id). */ readonly ariaLabelledby: _angular_core.InputSignal; /** @internal — referenced by AtlDialogHeader via ATL_DIALOG token */ readonly headerId: string; protected readonly dialogId: string; protected readonly dialogRef: _angular_core.Signal | undefined>; private readonly triggerEl; protected readonly panelClass: _angular_core.Signal; protected readonly hostClasses: _angular_core.Signal<"" | "is-open">; constructor(); protected onCancel(event: Event): void; protected onBackdropClick(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Header slot for `atl-dialog`. Renders above content with a bottom separator. * Automatically receives the correct `id` for `aria-labelledby` association. */ declare class AtlDialogHeader { protected readonly context: _atelier_ui_angular.AtlDialogContext; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Content slot for `atl-dialog`. Scrollable primary content area. */ declare class AtlDialogContent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Footer slot for `atl-dialog`. Renders below content, typically holds action buttons. */ declare class AtlDialogFooter { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface AtlDialogContext { headerId: string; close: () => void; } declare const ATL_DIALOG: InjectionToken; interface TabInfo { id: string; label: string; disabled: boolean; panelId: string; tabId: string; } interface AtlTabGroupContext { readonly selectedIndex: WritableSignal; readonly tabs: Signal; registerTab(info: TabInfo): void; unregisterTab(id: string): void; } declare const ATL_TAB_GROUP: InjectionToken; /** * Accessible tabbed interface container. Renders a tab list and manages * keyboard navigation with roving tabindex. * * Usage: * ```html * * Account settings here. * Notification prefs here. * Billing info here. * * ``` */ declare class AtlTabGroup implements AtlTabGroupContext { /** Index of the currently active tab. Supports two-way binding. */ readonly selectedIndex: _angular_core.ModelSignal; /** Visual variant. */ readonly variant: _angular_core.InputSignal<"default" | "pills">; /** @internal */ readonly tabs: _angular_core.WritableSignal; /** @internal */ protected readonly tabBtns: _angular_core.Signal[]>; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal — called by AtlTab on init */ registerTab(info: TabInfo): void; /** @internal — called by AtlTab on destroy */ unregisterTab(id: string): void; /** @internal */ protected selectTab(index: number): void; /** @internal */ protected onTabKeydown(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Individual tab definition. Place inside ``. * * Usage: * ```html * Settings content here. * ``` */ declare class AtlTab implements OnInit, OnDestroy { /** Text displayed on the tab button. Required. */ readonly label: _angular_core.InputSignal; /** Whether this tab is disabled. */ readonly disabled: _angular_core.InputSignal; /** @internal */ readonly tabId: string; /** @internal */ readonly panelId: string; /** @internal */ private readonly id; /** @internal */ private readonly context; /** @internal */ protected readonly isActive: _angular_core.Signal; ngOnInit(): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** @internal — shape required by AtlAccordionGroup's FocusKeyManager */ interface AccordionItem extends FocusableOption { readonly id: string; focus(): void; disabled?: boolean; } interface AtlAccordionGroupContext { register(item: AccordionItem): void; unregister(item: AccordionItem): void; handleKeydown(event: KeyboardEvent, item: AccordionItem): void; } declare const ATL_ACCORDION_GROUP: InjectionToken; /** * Container that manages accordion items. Controls single vs multi expansion * and provides keyboard navigation across items. * * Usage: * ```html * * * Title * Body content here. * * * ``` */ declare class AtlAccordionGroup implements AtlAccordionGroupContext { /** Allow multiple items to be expanded simultaneously. */ readonly multi: _angular_core.InputSignal; /** Visual variant. */ readonly variant: _angular_core.InputSignal<"default" | "bordered" | "separated">; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal */ get hostClassesValue(): string; /** @internal */ private readonly items; register(item: AccordionItem): void; unregister(item: AccordionItem): void; handleKeydown(event: KeyboardEvent, item: AccordionItem): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Directive to mark the accordion header content. */ declare class AtlAccordionHeader { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Individual collapsible accordion item. Place inside ``. * * Usage: * ```html * * Section Title * Section content goes here. * * ``` */ declare class AtlAccordionItem implements AccordionItem, OnInit, OnDestroy { /** Whether this item is expanded. Supports two-way binding. */ readonly expanded: _angular_core.ModelSignal; /** Whether this item is disabled. */ readonly disabledInput: _angular_core.InputSignal; /** * HTML heading level wrapping the trigger button. Default `3`. * Match your page's heading outline so heading order stays valid. * Rendered as `
` so screen * readers treat it as a real heading at that level. */ readonly headingLevel: _angular_core.InputSignal<1 | 2 | 3 | 4 | 5 | 6>; /** @internal — satisfies AccordionItem / FocusableOption interface */ get disabled(): boolean; /** @internal */ readonly id: string; /** @internal */ readonly triggerId: string; /** @internal */ readonly panelId: string; /** @internal */ private readonly group; /** @internal */ private readonly cdkItem; /** @internal */ private readonly el; /** @internal */ protected readonly isExpanded: _angular_core.WritableSignal; /** @internal */ get isExpandedValue(): boolean; /** @internal */ get isDisabled(): boolean; /** @internal */ get ariaDisabled(): boolean | null; constructor(); ngOnInit(): void; ngOnDestroy(): void; /** @internal — for FocusKeyManager */ focus(): void; /** @internal */ protected onToggle(): void; /** @internal */ protected onKeydown(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Trigger directive that opens an `` dropdown. * Apply to any element (typically ``) to wire up click + keyboard open/close. * * Usage: * ```html * Open * * * Action * * * ``` */ declare class AtlMenuTrigger { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Accessible dropdown menu panel. * Uses `@angular/cdk/menu` for keyboard navigation, focus management, and ARIA. * * Usage: * ```html * Actions * * * Copy * * Paste * * * ``` */ declare class AtlMenu { /** Visual variant. `compact` reduces font size and padding. */ readonly variant: _angular_core.InputSignal<"default" | "compact">; /** @internal */ protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A single item inside an ``. * Supports keyboard navigation, disabled state, and nested submenus via `[atlMenuTriggerFor]`. * * Usage: * ```html * Label * Disabled * ``` */ declare class AtlMenuItem { /** Whether this menu item is disabled. */ readonly disabled: _angular_core.InputSignal; /** @internal — detect if this item also triggers a submenu */ private readonly menuTrigger; /** @internal */ protected readonly hasSubmenu: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Visual separator between groups of menu items. * * Usage: * ```html * Copy * * Delete * ``` */ declare class AtlMenuSeparator { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Attribute directive that displays a text tooltip on hover or focus. * Uses `@angular/cdk/overlay` for viewport-aware positioning. * * Usage: * ```html * Save * Copy * ``` */ declare class AtlTooltip implements OnDestroy { /** The tooltip text. */ readonly atlTooltip: _angular_core.InputSignal; /** Preferred tooltip placement. Falls back to the opposite side if clipped. */ readonly atlTooltipPosition: _angular_core.InputSignal<"above" | "below" | "left" | "right">; /** Disable the tooltip without removing the directive. */ readonly atlTooltipDisabled: _angular_core.InputSignal; /** Delay in ms before the tooltip appears. */ readonly atlTooltipShowDelay: _angular_core.InputSignal; /** Delay in ms before the tooltip hides. */ readonly atlTooltipHideDelay: _angular_core.InputSignal; private readonly injector; private readonly elementRef; private overlayRef; private showTimer; private hideTimer; /** @internal — links host aria-describedby to the tooltip element */ protected readonly activeTooltipId: _angular_core.WritableSignal; /** @internal */ protected show(): void; /** @internal */ protected hide(): void; ngOnDestroy(): void; private attach; private createOverlay; private clearShowTimer; private clearHideTimer; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Loading placeholder that mimics the shape of content while it loads. * * Usage: * ```html * * * * ``` */ declare class AtlSkeleton { /** Shape variant of the skeleton placeholder. */ readonly variant: _angular_core.InputSignal<"text" | "circular" | "rectangular">; /** CSS width of the skeleton. */ readonly width: _angular_core.InputSignal; /** CSS height — when empty, a sensible default is chosen per variant. */ readonly height: _angular_core.InputSignal; /** Whether the shimmer animation is active. */ readonly animated: _angular_core.InputSignal; protected readonly computedHeight: _angular_core.Signal; protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** Variant types for toast notifications. */ type ToastVariant = 'default' | 'success' | 'warning' | 'danger' | 'info'; /** Options for creating a toast notification. */ interface ToastOptions { variant?: ToastVariant; /** Duration in ms before auto-dismiss. 0 = no auto-dismiss. Default 5000. */ duration?: number; /** Whether the toast shows a dismiss button. Default true. */ dismissible?: boolean; } /** Internal data for a toast instance. */ interface ToastData { id: string; message: string; variant: ToastVariant; duration: number; dismissible: boolean; } /** * Service for showing transient toast notifications. * * Usage: * ```typescript * const toast = inject(AtlToastService); * toast.show('Saved successfully', { variant: 'success' }); * ``` */ declare class AtlToastService { readonly toasts: _angular_core.WritableSignal; private readonly timers; /** * Show a toast notification. * @returns The unique id of the toast, which can be used with `dismiss()`. */ show(message: string, options?: ToastOptions): string; /** Dismiss a single toast by id. */ dismiss(id: string): void; /** Clear all active toasts. */ clear(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Individual toast notification. * * Typically rendered by `atl-toast-container`, but can also be used standalone. */ declare class AtlToast { /** Semantic color variant. */ readonly variant: _angular_core.InputSignal; /** Whether to show a dismiss button. */ readonly dismissible: _angular_core.InputSignal; /** The message to display. */ readonly message: _angular_core.InputSignal; /** Unique identifier for this toast. */ readonly toastId: _angular_core.InputSignal; /** Emitted when the toast is dismissed by the user. */ readonly dismissed: _angular_core.OutputEmitterRef; protected readonly hostClasses: _angular_core.Signal; protected onDismiss(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Container that renders the toast stack at a fixed viewport position. * Place once in your app root or layout component. * * Usage: * ```html * * ``` */ declare class AtlToastContainer { protected readonly toastService: AtlToastService; private readonly destroyRef; /** Position of the toast stack on the viewport. */ readonly position: _angular_core.InputSignal<"top-right" | "top-center" | "bottom-right" | "bottom-center">; protected readonly hostClasses: _angular_core.Signal; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Displays a user avatar with image, initials, or icon fallback. * * Fallback order: image → initials (from `name`) → generic icon. * * Usage: * ```html * * * * ``` */ declare class AtlAvatar { /** Image URL. Falls back to initials or icon if empty or fails to load. */ readonly src: _angular_core.InputSignal; /** Alt text for the image (also used as aria-label). */ readonly alt: _angular_core.InputSignal; /** Full name used to generate initials fallback and default aria-label. */ readonly name: _angular_core.InputSignal; /** Size of the avatar. */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xs" | "xl">; /** Shape of the avatar. */ readonly shape: _angular_core.InputSignal<"circle" | "square">; /** Presence status indicator dot. Empty string hides the dot. */ readonly status: _angular_core.InputSignal<"" | "online" | "offline" | "away" | "busy">; /** @internal — reset to true whenever src changes */ protected readonly showImage: _angular_core.WritableSignal; /** @internal */ protected readonly initials: _angular_core.Signal; /** @internal */ protected readonly ariaLabel: _angular_core.Signal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Groups multiple avatars with overlap and an overflow count badge. * * Usage: * ```html * * * * * * * ``` */ declare class AtlAvatarGroup { /** Maximum visible avatars before showing an overflow count. */ readonly max: _angular_core.InputSignal; /** Size applied to the overflow badge (match the size used on child avatars). */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xs" | "xl">; private readonly avatarEls; protected readonly overflowCount: _angular_core.Signal; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Progress bar with determinate and indeterminate states. * * Usage: * ```html * * * * ``` */ declare class AtlProgress { /** Current value of the progress bar. */ readonly value: _angular_core.InputSignal; /** Maximum value. */ readonly max: _angular_core.InputSignal; /** Semantic color variant. */ readonly variant: _angular_core.InputSignal<"danger" | "default" | "success" | "warning">; /** Height size of the track. */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">; /** Shows an animated indeterminate state (loading). */ readonly indeterminate: _angular_core.InputSignal; /** * Accessible name — rendered as `aria-label` on the host. * Required by ARIA when there is no visible label nearby. */ readonly label: _angular_core.InputSignal; protected readonly clampedValue: _angular_core.Signal; protected readonly fillWidth: _angular_core.Signal; protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accessible breadcrumb navigation. Wrap `atl-breadcrumb-item` elements inside. * The last item is automatically marked as the current page. * * Usage: * ```html * * Home * Products * Widget X * * ``` */ declare class AtlBreadcrumbs { readonly separator: _angular_core.InputSignal; protected readonly separatorCssVar: _angular_core.Signal; private readonly _itemIds; private _nextId; /** @internal — used by AtlBreadcrumbItem via ATL_BREADCRUMBS token */ readonly lastItemId: _angular_core.Signal; /** @internal */ registerItem(): number; /** @internal */ unregisterItem(id: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A single breadcrumb step. The last item is automatically treated as * `aria-current="page"` and rendered as plain text (no link). */ declare class AtlBreadcrumbItem implements OnInit, OnDestroy { /** Optional href for navigation. Ignored on the last (current) item. */ readonly href: _angular_core.InputSignal; private readonly context; private readonly myIndex; protected readonly isCurrent: _angular_core.Signal; ngOnInit(): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface AtlBreadcrumbsContext { registerItem(): number; unregisterItem(id: number): void; readonly lastItemId: Signal; } declare const ATL_BREADCRUMBS: InjectionToken; type PageItem = { type: 'page'; page: number; } | { type: 'ellipsis'; key: string; }; /** * Pagination control for navigating multi-page content. * * Usage: * ```html * * ``` */ declare class AtlPagination { /** Current page (1-based). Supports two-way binding: [(page)]="currentPage". */ readonly page: _angular_core.ModelSignal; /** Total number of pages. */ readonly pageCount: _angular_core.InputSignal; /** Number of page buttons to show on each side of the current page. */ readonly siblingCount: _angular_core.InputSignal; /** Whether to show first/last page jump buttons. */ readonly showFirstLast: _angular_core.InputSignal; protected readonly pageItems: _angular_core.Signal; protected goTo(p: number): void; protected goPrev(): void; protected goNext(): void; protected goFirst(): void; protected goLast(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Slide-in drawer panel using the native `` element. * Supports left, right, top, and bottom positions with focus trap, * Escape to close, and backdrop click to close. * Compose with `atl-drawer-header`, `atl-drawer-content`, and `atl-drawer-footer`. * * Usage: * ```html * Open * * Settings * Content here. * * Save * * * ``` */ declare class AtlDrawer { /** Whether the drawer is open. Supports two-way binding: [(open)]="isOpen". */ readonly open: _angular_core.ModelSignal; /** Which edge the drawer slides in from. */ readonly position: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">; /** Width (for left/right) or height (for top/bottom) of the panel. */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "full">; /** Whether clicking the backdrop closes the drawer. */ readonly closeOnBackdrop: _angular_core.InputSignal; /** @internal — referenced by AtlDrawerHeader via ATL_DRAWER token */ readonly headerId: string; protected readonly drawerId: string; protected readonly dialogRef: _angular_core.Signal | undefined>; private readonly triggerEl; protected readonly hostClasses: _angular_core.Signal; constructor(); protected onCancel(event: Event): void; protected onBackdropClick(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Header slot for `atl-drawer`. Contains the title and a close button. * Automatically receives the correct `id` for `aria-labelledby` association. */ declare class AtlDrawerHeader { protected readonly context: _atelier_ui_angular.AtlDrawerContext; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Content slot for `atl-drawer`. Scrollable primary content area. */ declare class AtlDrawerContent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Footer slot for `atl-drawer`. Renders at the bottom with action buttons. */ declare class AtlDrawerFooter { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface AtlDrawerContext { headerId: string; close: () => void; } declare const ATL_DRAWER: InjectionToken; interface AtlTableContext { readonly size: Signal<'sm' | 'md' | 'lg'>; readonly variant: Signal<'default' | 'striped' | 'bordered'>; } declare const ATL_TABLE: InjectionToken; /** * Accessible data table with sorting, row selection, sticky header, and empty state. * Compose with `atl-thead`, `atl-tbody`, `atl-tr`, `atl-th`, and `atl-td`. * * Usage: * ```html * * * * Name * Status * * * * @for (row of rows; track row.id) { * * {{ row.name }} * {{ row.status }} * * } *
No results found.
*
*
* ``` */ declare class AtlTable implements AtlTableContext { /** Visual style of the table rows. */ readonly variant: _angular_core.InputSignal<"default" | "bordered" | "striped">; /** Row density. */ readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">; /** Whether the header row sticks to the top when the table scrolls. */ readonly stickyHeader: _angular_core.InputSignal; /** * Accessible name for the scrollable table region. Surfaces to * screen readers as the region's label so keyboard users who * scroll the wrapper know what they're scrolling. Defaults to * `"Table"` if unset. */ readonly ariaLabel: _angular_core.InputSignal; /** @internal */ protected readonly hostClasses: Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Table head section. Contains header rows with `atl-tr` and `atl-th`. * * Usage: * ```html * * * Name * * * ``` */ declare class AtlThead { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Table body section. Shows rows or an empty state. * * Usage: * ```html * * @for (row of rows; track row.id) { * {{ row.name }} * } *
No results found.
*
* ``` */ declare class AtlTbody { /** When true, hides rows and shows the `[atlTableEmpty]` slot content instead. */ readonly empty: _angular_core.InputSignal; /** Number of columns to span in the empty-state row. Should match total column count. */ readonly colSpan: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Table row. Use inside `atl-thead` or `atl-tbody`. * Set `selectable` to auto-add a checkbox column for row selection. * * Usage: * ```html * * Cell content * * ``` */ declare class AtlTr { /** Whether this row is currently selected. */ readonly selected: _angular_core.InputSignal; /** Whether this row shows a selection checkbox. */ readonly selectable: _angular_core.InputSignal; /** Optional identifier for this row. Useful for tracking selection. */ readonly rowId: _angular_core.InputSignal; /** Emits when the row's checkbox is toggled. */ readonly selectedChange: _angular_core.OutputEmitterRef; /** @internal */ protected readonly hostClasses: Signal<"" | "is-selectable">; /** @internal — applied to inner for CSS selection styling */ protected readonly innerClasses: Signal<"" | "is-selected">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** Sort direction for sortable column headers. */ type AtlSortDirection = 'asc' | 'desc' | null; /** * Table header cell. Set `sortable` to enable sort cycling. * The consumer controls `sortDirection` (fully controlled — no internal state). * * Usage: * ```html * Name * ``` */ declare class AtlTh { /** Whether this column is sortable. Renders a sort button when true. */ readonly sortable: _angular_core.InputSignal; /** Current sort direction. Fully controlled — the consumer owns this state. */ readonly sortDirection: _angular_core.InputSignal; /** Text alignment of the header cell content. */ readonly align: _angular_core.InputSignal<"start" | "center" | "end">; /** Fixed column width (e.g. `'120px'`, `'10rem'`). */ readonly width: _angular_core.InputSignal; /** * Emits when the header is clicked. * Cycles: `null` → `'asc'` → `'desc'` → `null`. */ readonly sort: _angular_core.OutputEmitterRef; /** @internal */ protected readonly ariaSort: Signal<"none" | "ascending" | "descending" | undefined>; /** @internal */ protected readonly cellClasses: Signal; /** @internal */ protected cycleSort(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Table data cell. Use inside `atl-tr` inside `atl-tbody`. * * Usage: * ```html * {{ value }} * ``` */ declare class AtlTd { /** Text alignment of the cell content. */ readonly align: _angular_core.InputSignal<"start" | "center" | "end">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface StepInfo { id: string; label: string; description?: string; completed: boolean; error: boolean; optional: boolean; disabled: boolean; } interface AtlStepperContext { readonly activeStep: WritableSignal; readonly steps: Signal; readonly linear: Signal; registerStep(info: StepInfo): void; unregisterStep(id: string): void; updateStep(id: string, info: Partial): void; goTo(index: number): void; next(): void; prev(): void; } declare const ATL_STEPPER: InjectionToken; /** * Multi-step wizard container. * * Usage: * ```html * * Account form here. * Profile form here. * Review and submit. * * ``` */ declare class AtlStepper implements AtlStepperContext { /** Index of the currently active step. Supports two-way binding. */ readonly activeStep: _angular_core.ModelSignal; /** Layout orientation. */ readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">; /** * When true, users can only navigate to completed steps or the next pending step. * Use `goTo()` / `next()` in your step content to advance programmatically. */ readonly linear: _angular_core.InputSignal; /** @internal */ readonly steps: _angular_core.WritableSignal; /** @internal */ protected readonly hostClasses: _angular_core.Signal; /** @internal — called by AtlStep on init */ registerStep(info: StepInfo): void; /** @internal — called by AtlStep on destroy */ unregisterStep(id: string): void; /** @internal — called by AtlStep effect when inputs change */ updateStep(id: string, info: Partial): void; /** Navigate to a specific step index. Respects linear mode. */ goTo(index: number): void; /** Advance to the next step. */ next(): void; /** Go back to the previous step. */ prev(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Individual step. Place inside ``. * * Usage: * ```html * Account form here. * ``` */ declare class AtlStep implements OnInit, OnDestroy { /** Text displayed on the step indicator. Required. */ readonly label: _angular_core.InputSignal; /** Optional subtitle shown below the label. */ readonly description: _angular_core.InputSignal; /** Mark this step as completed (shows a checkmark). */ readonly completed: _angular_core.InputSignal; /** Mark this step as having an error (shows an X). */ readonly error: _angular_core.InputSignal; /** Mark this step as optional. */ readonly optional: _angular_core.InputSignal; /** Whether this step is disabled. */ readonly disabled: _angular_core.InputSignal; /** @internal */ private readonly id; /** @internal */ private readonly context; /** @internal */ protected readonly myIndex: _angular_core.Signal; /** @internal */ protected readonly isActive: _angular_core.Signal; constructor(); ngOnInit(): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Displays a block of code with an optional header, language label, and copy button. * Designed for rendering LLM-generated code output, inline snippets, and API examples. * * Usage: * ```html * * * ``` */ declare class AtlCodeBlock { /** The code string to display. */ readonly code: _angular_core.InputSignal; /** Language label shown in the header. Ignored if filename is set. */ readonly language: _angular_core.InputSignal; /** Optional filename shown in the header instead of the language label. */ readonly filename: _angular_core.InputSignal; /** Whether to show a copy-to-clipboard button. */ readonly copyable: _angular_core.InputSignal; /** Whether to display line numbers alongside the code. */ readonly showLineNumbers: _angular_core.InputSignal; protected readonly copied: _angular_core.WritableSignal; protected readonly displayLabel: _angular_core.Signal; protected readonly lines: _angular_core.Signal; protected copy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * AI assistant surface. Three layout variants share the same content slots * and can be swapped without changing the children. * * Variants: * - `drawer`: Right-anchored slide-in panel, full viewport height. * - `popup`: Floating bubble (bottom-right) + compact chat window. * - `inline`: Embedded card, sits inline with page content. * * Compose with `atl-chat-header`, `atl-chat-messages`, `atl-chat-input`. * * Usage: * ```html * * AI Assistant * * Hi! How can I help? * Show me a sorting function. * * * * ``` */ declare class AtlChat { /** Layout variant. */ readonly variant: _angular_core.InputSignal; /** Whether the chat is open. Used by drawer/popup; ignored by inline. Two-way bindable via [(open)]. */ readonly open: _angular_core.ModelSignal; /** Connection / response status. Drives badge color in header and disables input while streaming. */ readonly status: _angular_core.InputSignal; /** @internal — referenced by AtlChatHeader via ATL_CHAT token for aria-labelledby. */ readonly headerId: string; protected readonly dialogRef: _angular_core.Signal | undefined>; private readonly host; private readonly triggerEl; protected readonly hostClasses: _angular_core.Signal; constructor(); protected onCancel(event: Event): void; protected onBackdropClick(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Header slot for `atl-chat`. Holds the title, status indicator, and close button. * Children are projected into the title area; the close button is rendered automatically. */ declare class AtlChatHeader { protected readonly context: _atelier_ui_angular.AtlChatContext; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Scrollable message list for `atl-chat`. Project `atl-chat-message`, * `atl-chat-typing`, or `atl-chat-suggestion` children inside. Auto-scrolls * to the bottom whenever children are added or content changes — important * for streaming responses where new tokens are appended live. */ declare class AtlChatMessages { private readonly host; private readonly destroyRef; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A single chat message. Role drives bubble alignment and color. * * Usage: * ```html * Sure, here you go. * Thanks! * Couldn't reach the assistant. * ``` */ declare class AtlChatMessage { /** Sender of the message. Drives bubble alignment and color. */ readonly role: _angular_core.InputSignal; /** Marks the message as failed (red dashed border, used in error state). */ readonly failed: _angular_core.InputSignal; protected readonly hostClasses: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Typing indicator (three animated dots). * * Two display modes: * - **Standalone bubble** (default) — render as the last child of * `AtlChatMessages` to show "the assistant is starting to respond" * before any tokens arrive. * - **Inline cursor** (`inline`) — render as the LAST child INSIDE * `AtlChatMessage role="assistant"` to show the dots after the * currently-streaming text. The bubble background is dropped so the * dots read as a typing caret at the end of the partial response. */ declare class AtlChatTyping { /** When true, renders as an inline cursor without bubble chrome. */ readonly inline: _angular_core.InputSignal; protected readonly hostClasses: _angular_core.Signal<"" | "is-inline">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Tappable suggestion chip used in the empty state to seed a conversation. * * Usage: * ```html * * ``` */ declare class AtlChatSuggestion { /** Primary label of the suggestion. */ readonly label: _angular_core.InputSignal; /** Optional secondary hint text shown below the label. */ readonly hint: _angular_core.InputSignal; /** Fires the label string when the chip is activated. */ readonly selected: _angular_core.OutputEmitterRef; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Composable input footer for `atl-chat`. Wraps a text field and emits * `send` (or `stop` while the assistant is streaming). * * The button automatically switches to a `danger` "Stop" button when the * parent chat's `status` is `'streaming'`. * * Usage: * ```html * * ``` */ declare class AtlChatInput { /** Placeholder shown in the empty input. Defaults change per parent status. */ readonly placeholder: _angular_core.InputSignal; /** Accessible label for the input field. */ readonly ariaLabel: _angular_core.InputSignal; /** Two-way bindable text content. */ readonly value: _angular_core.ModelSignal; /** Fires when Enter is pressed (without Shift) or the Send button is clicked. */ readonly send: _angular_core.OutputEmitterRef; /** Fires when the Stop button is clicked while the parent chat is streaming. */ readonly stop: _angular_core.OutputEmitterRef; protected readonly context: _atelier_ui_angular.AtlChatContext; protected readonly isStreaming: _angular_core.Signal; protected readonly effectivePlaceholder: _angular_core.Signal; protected onInput(event: Event): void; protected onEnter(event: Event): void; protected emitSend(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Context token used by `atl-chat` sub-components (header, input) to * read parent state and dispatch close/toggle actions without a direct * component reference. */ interface AtlChatContext { readonly headerId: string; readonly variant: Signal; readonly status: Signal; close(): void; toggle(): void; } declare const ATL_CHAT: InjectionToken; export { ATL_ACCORDION_GROUP, ATL_BREADCRUMBS, ATL_CHAT, ATL_DIALOG, ATL_DRAWER, ATL_RADIO_GROUP, ATL_SELECT, ATL_STEPPER, ATL_TABLE, ATL_TAB_GROUP, AtlAccordionGroup, AtlAccordionHeader, AtlAccordionItem, AtlAlert, AtlAvatar, AtlAvatarGroup, AtlBadge, AtlBreadcrumbItem, AtlBreadcrumbs, AtlButton, AtlCard, AtlCardContent, AtlCardFooter, AtlCardHeader, AtlChat, AtlChatHeader, AtlChatInput, AtlChatMessage, AtlChatMessages, AtlChatSuggestion, AtlChatTyping, AtlCheckbox, AtlCodeBlock, AtlCombobox, AtlDialog, AtlDialogContent, AtlDialogFooter, AtlDialogHeader, AtlDrawer, AtlDrawerContent, AtlDrawerFooter, AtlDrawerHeader, AtlIcon, AtlInput, AtlMenu, AtlMenuItem, AtlMenuSeparator, AtlMenuTrigger, AtlOption, AtlPagination, AtlProgress, AtlRadio, AtlRadioGroup, AtlSelect, AtlSkeleton, AtlStep, AtlStepper, AtlTab, AtlTabGroup, AtlTable, AtlTbody, AtlTd, AtlTextarea, AtlTh, AtlThead, AtlToast, AtlToastContainer, AtlToastService, AtlToggle, AtlTooltip, AtlTr }; export type { AtlAccordionGroupContext, AtlBreadcrumbsContext, AtlChatContext, AtlDialogContext, AtlDrawerContext, AtlRadioGroupContext, AtlSelectContext, AtlSortDirection, AtlStepperContext, AtlTabGroupContext, AtlTableContext, PageItem, StepInfo, TabInfo, ToastData, ToastOptions };