import * as _angular_core from '@angular/core'; import { TemplateRef, OnInit, ElementRef, InjectionToken, Type, AfterViewInit, OnDestroy, Renderer2, WritableSignal, Signal, AfterContentInit, QueryList, EventEmitter, ComponentRef, InputSignal, OutputEmitterRef, OnChanges, SimpleChanges } from '@angular/core'; import { ControlValueAccessor } from '@angular/forms'; import { CheckCircle32, Uploading32, WarningCircle32 } from '@mozaic-ds/icons-angular'; import { RouterLink } from '@angular/router'; import { OverlayRef, ConnectedPosition } from '@angular/cdk/overlay'; import * as rxjs from 'rxjs'; import { Observable } from 'rxjs'; import { CdkPortalOutlet } from '@angular/cdk/portal'; import * as _mozaic_ds_angular from '@mozaic-ds/angular'; import { CdkDragDrop } from '@angular/cdk/drag-drop'; import { ComponentHarness } from '@angular/cdk/testing'; type MozBreadcrumbAppearance = 'standard' | 'inverse'; interface MozBreadcrumbLink { label: string; href: string; router?: boolean; } declare class MozBreadcrumbComponent { readonly appearance: _angular_core.InputSignal; readonly links: _angular_core.InputSignal; readonly classObject: _angular_core.Signal<{ [x: string]: boolean | MozBreadcrumbAppearance; breadcrumb: boolean; }>; getLinkClass(): string; getCurrentLinkClass(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozButtonAppearance = 'standard' | 'accent' | 'danger' | 'inverse'; type MozButtonSize = 's' | 'm' | 'l'; type MozButtonIconPosition = 'left' | 'right' | 'only' | null; type MozButtonType = 'button' | 'submit' | 'reset'; declare class MozButtonComponent { readonly appearance: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly ghost: _angular_core.InputSignal; readonly outlined: _angular_core.InputSignal; readonly iconPosition: _angular_core.InputSignal; readonly type: _angular_core.InputSignal; readonly isLoading: _angular_core.InputSignal; readonly iconTpl: _angular_core.Signal | undefined>; readonly classes: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozCheckboxComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; readonly indeterminate: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly indented: _angular_core.InputSignal; _value: _angular_core.WritableSignal; onChange: (_: boolean) => void; onTouched: () => void; readonly classObject: _angular_core.Signal<{ 'is-invalid': boolean; }>; readonly classes: _angular_core.Signal<{ checkbox: boolean; 'checkbox--indented': boolean; }>; writeValue(value: boolean): void; registerOnChange(fn: (_: boolean) => void): void; registerOnTouched(fn: () => void): void; onInputChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozCheckboxGroupComponent implements ControlValueAccessor { readonly name: _angular_core.InputSignal; readonly legend: _angular_core.InputSignal; readonly necessityIndicator: _angular_core.InputSignal; readonly helpText: _angular_core.InputSignal; readonly helpId: _angular_core.InputSignal; readonly options: _angular_core.InputSignal<{ id: string; label: string; value: string; disabled?: boolean; isInvalid?: boolean; }[] | undefined>; readonly inline: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; readonly containerClass: _angular_core.Signal<{ field__content: boolean; 'field__content--inline': boolean; }>; onChange: (_: string[]) => void; onTouched: () => void; writeValue(value: string[]): void; registerOnChange(fn: (value: string[]) => void): void; registerOnTouched(fn: () => void): void; toggleSelection(event: Event, val: string): void; isChecked(value: string): boolean; getCheckboxInputClass(option: { isInvalid?: boolean; }): { [key: string]: boolean; }; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozDividerOrientation = 'horizontal' | 'vertical'; type MozDividerAppearance = 'primary' | 'secondary' | 'tertiary' | 'inverse'; type MozDividerSize = 's' | 'm' | 'l'; /** * A divider is a visual element used to separate content or sections within an interface. It helps improve readability and organization by creating clear distinctions between groups of information. Dividers can be thin lines, thick separators, or even styled with spacing variations, adapting to different layouts. They are commonly used in menus, lists, forms, and content blocks to create a structured visual hierarchy. */ declare class MozDividerComponent { /** * Determines the orientation of the divider. */ readonly orientation: _angular_core.InputSignal; /** * Determines the appearance of the divider. */ readonly appearance: _angular_core.InputSignal; /** * Determines the size of the divider. */ readonly size: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozDividerOrientation; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozFieldComponent { readonly id: _angular_core.InputSignal; readonly labelTemplate: _angular_core.Signal | undefined>; readonly requirementTemplate: _angular_core.Signal | undefined>; readonly helpTemplate: _angular_core.Signal | undefined>; readonly helpId: _angular_core.InputSignal; readonly isValid: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly messageId: _angular_core.InputSignal; readonly message: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ 'mc-field__validation-message': boolean; 'is-valid': boolean; 'is-invalid': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozFieldGroupComponent { readonly id: _angular_core.InputSignal; readonly legend: _angular_core.InputSignal; readonly requirementText: _angular_core.InputSignal; readonly helpText: _angular_core.InputSignal; readonly isValid: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly message: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozFileUploaderFormat = 'inline' | 'stacked'; declare class MozFileUploaderComponent implements OnInit { readonly id: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; readonly helpText: _angular_core.InputSignal; readonly helpId: _angular_core.InputSignal; readonly necessityIndicator: _angular_core.InputSignal; readonly hasDragDrop: _angular_core.InputSignal; readonly showFilesList: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly multipleFiles: _angular_core.InputSignal; readonly accept: _angular_core.InputSignal; readonly title: _angular_core.InputSignal; readonly subtitle: _angular_core.InputSignal; readonly uploadButtonLabel: _angular_core.InputSignal; readonly format: _angular_core.InputSignal; readonly errorMessage: _angular_core.InputSignal; readonly invalid: _angular_core.InputSignal; readonly uploading: _angular_core.InputSignal; readonly hasPreview: _angular_core.InputSignal; readonly retryButtonLabel: _angular_core.InputSignal; readonly deleteButtonLabel: _angular_core.InputSignal; readonly previewButtonLabel: _angular_core.InputSignal; readonly information: _angular_core.InputSignal; readonly fileInformation: _angular_core.InputSignal<((file: File) => string) | undefined>; readonly retryFile: _angular_core.OutputEmitterRef; readonly previewFile: _angular_core.OutputEmitterRef; readonly files: _angular_core.WritableSignal; readonly isDragged: _angular_core.WritableSignal; readonly initialFiles: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ 'file-uploader--draggable': boolean; }>; readonly inputClasses: _angular_core.Signal<{ 'file-uploader__input--disabled': boolean; 'file-uploader__input--dragged': boolean; }>; readonly iconTpl: any; readonly fileInput: _angular_core.Signal | undefined>; ngOnInit(): void; removeFile(index: number): void; onDeleteFile(file: File): void; onRetryFile(file: File): void; onPreviewFile(file: File): void; onFileSelect(event: Event): void; onDrop(event: DragEvent): void; openFileDialog(): void; onDragOver(event: DragEvent): void; onDragLeave(event: DragEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozFileUploaderItemFormat = 'inline' | 'stacked'; declare class MozFileUploaderItemComponent { readonly format: _angular_core.InputSignal; readonly invalid: _angular_core.InputSignal; readonly uploading: _angular_core.InputSignal; readonly errorMessage: _angular_core.InputSignal; readonly hasPreview: _angular_core.InputSignal; readonly file: _angular_core.InputSignal; readonly fileInformation: _angular_core.InputSignal<((file: File) => string) | undefined>; readonly retryButtonLabel: _angular_core.InputSignal; readonly deleteButtonLabel: _angular_core.InputSignal; readonly previewButtonLabel: _angular_core.InputSignal; readonly delete: _angular_core.OutputEmitterRef; readonly retry: _angular_core.OutputEmitterRef; readonly preview: _angular_core.OutputEmitterRef; readonly fileName: _angular_core.Signal; readonly fileInfo: _angular_core.Signal; readonly isInline: _angular_core.Signal; readonly stateModifier: _angular_core.Signal<"default" | "error" | "loading">; readonly modifierClass: _angular_core.Signal; readonly isUploading: _angular_core.Signal; readonly stateIcon: _angular_core.Signal; readonly showInlineActions: _angular_core.Signal; readonly showStackedActions: _angular_core.Signal; onDelete(): void; onRetry(): void; onPreview(): void; private formatFileSize; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozIconButtonAppearance = 'standard' | 'accent' | 'danger' | 'inverse'; type MozIconButtonSize = 's' | 'm' | 'l'; type MozIconButtonType = 'button' | 'reset' | 'submit'; declare class MozIconButtonComponent { readonly id: _angular_core.InputSignal; readonly appearance: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly ghost: _angular_core.InputSignal; readonly outlined: _angular_core.InputSignal; readonly type: _angular_core.InputSignal; readonly ariaLabel: _angular_core.InputSignal; readonly activated: _angular_core.OutputEmitterRef; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozIconButtonAppearance | MozIconButtonSize; 'mc-button': boolean; 'mc-button--icon-button': boolean; 'mc-button--ghost': boolean; 'mc-button--outlined': boolean; }>; onActivated(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozLinkAppearance = 'secondary' | 'accent' | 'inverse' | 'standard'; type MozLinkSize = 's' | 'm'; type MozLinkIconPosition = 'left' | 'right' | 'only'; declare class MozLinkComponent { readonly href: _angular_core.InputSignal; readonly target: _angular_core.InputSignal; readonly appearance: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly inline: _angular_core.InputSignal; readonly router: _angular_core.InputSignal; readonly iconPosition: _angular_core.InputSignal; readonly current: _angular_core.InputSignal; readonly ariaCurrent: _angular_core.InputSignal; private readonly routerLinkActive; readonly routerLink: RouterLink | null; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozLinkAppearance | MozLinkSize; link: boolean; 'link--inline': boolean; 'link--stand-alone': boolean; 'link--active': boolean; 'link--breadcrumb__current': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozLoaderAppearance = 'standard' | 'accent' | 'inverse'; type MozLoaderSize = 'xs' | 's' | 'm' | 'l'; declare class MozLoaderComponent { readonly appearance: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly text: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozLoaderAppearance | MozLoaderSize; loader: boolean; "loader--text-visible": boolean; }>; readonly viewBox: _angular_core.Signal<"0 0 20 20" | "0 0 24 24" | "0 0 64 64" | "0 0 32 32">; readonly circleRadius: _angular_core.Signal<3 | 6 | 9 | 19>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozLoadingOverlayComponent { readonly label: _angular_core.InputSignal; readonly visible: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozModalSize = 's' | 'm' | 'l'; declare class MozModalComponent { readonly title: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly hasCloseButton: _angular_core.InputSignal; readonly closeOnBackdrop: _angular_core.InputSignal; readonly isOpen: _angular_core.ModelSignal; readonly footerTpl: _angular_core.Signal | undefined>; readonly classes: _angular_core.Signal<{ [x: string]: boolean; modal: boolean; 'is-open': boolean; }>; open(): void; close(): void; onBackdropClick(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface MozModalConfig { title: string; size?: MozModalSize; hasCloseButton?: boolean; closeOnBackdrop?: boolean; closeOnEscape?: boolean; data?: D; } declare const MODAL_CONFIG: InjectionToken>; declare const MODAL_DATA: InjectionToken; declare const DEFAULT_MODAL_CONFIG: Partial; declare class MozModalRef { private readonly overlayRef; private readonly afterClosed$; private readonly afterOpened$; readonly isOpen: _angular_core.WritableSignal; readonly title: _angular_core.WritableSignal; readonly size: _angular_core.WritableSignal; readonly hasCloseButton: _angular_core.WritableSignal; readonly closeOnBackdrop: _angular_core.WritableSignal; readonly closeOnEscape: _angular_core.WritableSignal; private animationDuration; constructor(overlayRef: OverlayRef); open(): void; close(result?: R): void; afterClosed(): Observable; afterOpened(): Observable; } declare class MozModalService { private readonly overlay; private readonly injector; open(component: Type, config: MozModalConfig): MozModalRef; private createOverlay; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class MozModalFooterDirective { private readonly tpl; private readonly container; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } type MozNumberBadgeAppearance = 'danger' | 'accent' | 'inverse' | 'standard'; type MozNumberBadgeSize = 's' | 'm'; declare class MozNumberBadgeComponent { readonly label: _angular_core.InputSignal; readonly appearance: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozNumberBadgeAppearance | MozNumberBadgeSize; 'mc-number-badge': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozOverlayComponent { readonly backdropClick: _angular_core.OutputEmitterRef; readonly backdropKeydown: _angular_core.OutputEmitterRef; /** * Controls the visibility of the overlay. */ readonly isVisible: _angular_core.InputSignal; /** * Accessible label for the overlay dialog. */ readonly dialogLabel: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ overlay: boolean; 'is-visible': boolean | undefined; }>; onBackdropClick(): void; noop(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozPaginationButtonAppearance = 'rounded' | 'square'; type MozPaginationButtonSize = 's' | 'm'; declare class MozPaginationComponent { readonly id: _angular_core.InputSignal; readonly compact: _angular_core.InputSignal; readonly options: _angular_core.InputSignal<{ text: string; value: number; }[]>; readonly selectLabel: _angular_core.InputSignal; readonly buttonAppearance: _angular_core.InputSignal; readonly buttonSize: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly updateValue: _angular_core.OutputEmitterRef; readonly _currentValue: _angular_core.WritableSignal; readonly currentIndex: _angular_core.Signal; readonly isFirstPage: _angular_core.Signal; readonly isLastPage: _angular_core.Signal; readonly currentPageText: _angular_core.Signal; previous(): void; next(): void; onSelectChange(value: string): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Directive that transforms a simple input into a styled password input with toggle visibility and clearable button. * Wraps the input element in a container and adds additional elements as needed. */ declare class MozPasswordInputDirective implements ControlValueAccessor, AfterViewInit, OnDestroy { private elementRef; private renderer; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly clearable: _angular_core.InputSignal; readonly clearLabel: _angular_core.InputSignal; readonly buttonLabel: _angular_core.InputSignal<{ show: string; hide: string; }>; private wrapper; private clearButton; private toggleButton; private clearIconComponentRef; private environmentInjector; protected _value: _angular_core.WritableSignal; private _isVisible; readonly inputType: _angular_core.Signal<"text" | "password">; readonly ariaChecked: _angular_core.Signal<"true" | "false">; readonly isClearable: _angular_core.Signal; /** Get the current value of the input */ getValue(): string; onChange: (value: string) => void; onTouched: () => void; constructor(elementRef: ElementRef, renderer: Renderer2); ngAfterViewInit(): void; ngOnDestroy(): void; private wrapInput; private createClearButton; private createToggleButton; private updateClearButtonVisibility; private updateToggleButtonText; clearValue(): void; toggleVisibility(): void; onInput(event: Event): void; writeValue(value: string): void; registerOnChange(fn: (value: string) => void): void; registerOnTouched(fn: () => void): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozPincodeLength = 4 | 5 | 6; declare class MozPincodeInputComponent implements OnInit, ControlValueAccessor { private readonly cdr; private readonly ngZone; readonly id: _angular_core.InputSignal; readonly length: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly readonly: _angular_core.InputSignal; readonly otp: WritableSignal; readonly inputRefs: _angular_core.Signal[]>; private _value; onChange: (value: string) => void; onTouched: () => void; readonly classes: _angular_core.Signal<{ 'mc-pincode-input': boolean; 'is-invalid': boolean; }>; ngOnInit(): void; writeValue(value: string): void; registerOnChange(fn: (value: string) => void): void; registerOnTouched(fn: () => void): void; private focusInput; onInput(event: Event, index: number): void; onKeyDown(event: KeyboardEvent, index: number): void; onBackspace(event: KeyboardEvent, index: number): void; onPaste(event: ClipboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozQuantitySelectorSize = 's' | 'm'; declare class MozQuantitySelectorComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly readonly: _angular_core.InputSignal; readonly min: _angular_core.InputSignal; readonly max: _angular_core.InputSignal; readonly step: _angular_core.InputSignal; readonly incrementLabel: _angular_core.InputSignal; readonly decrementLabel: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozQuantitySelectorSize; 'quantity-selector': boolean; 'is-invalid': boolean; }>; private onChange; private onTouched; writeValue(value: number): void; registerOnChange(fn: (value: number) => void): void; registerOnTouched(fn: () => void): void; onChangeInput(event: Event): void; increment(): void; decrement(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozRadioComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; onChange: (_: boolean) => void; onTouched: () => void; handleChange(event: Event): void; writeValue(value: boolean): void; registerOnChange(fn: (value: boolean) => void): void; registerOnTouched(fn: () => void): void; readonly classes: _angular_core.Signal<{ radio__input: boolean; 'is-invalid': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozRadioGroupComponent implements ControlValueAccessor { readonly name: _angular_core.InputSignal; readonly options: _angular_core.InputSignal<{ id: string; label: string; value: string; disabled?: boolean; }[]>; readonly isInvalid: _angular_core.InputSignal; readonly inline: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; onChange: (value: string) => void; onTouched: () => void; writeValue(value: string): void; registerOnChange(fn: (value: string) => void): void; registerOnTouched(fn: () => void): void; select(value: string): void; readonly classes: _angular_core.Signal<{ field__content: boolean; 'field__content--inline': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozSelectValue = string | number | null; type MozSelectOption = { id?: string; text: string; value: string | number; attributes?: Record; disabled?: boolean; }; type MozSelectSize = 's' | 'm'; declare class MozSelectComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly options: _angular_core.InputSignal; readonly placeholder: _angular_core.InputSignal; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly readonly: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; onChange: (value: MozSelectValue) => void; onTouched: () => void; writeValue(value: MozSelectValue): void; registerOnChange(fn: (value: MozSelectValue) => void): void; registerOnTouched(fn: () => void): void; handleChange(event: Event): void; readonly hostClasses: _angular_core.Signal<{ [x: string]: boolean | MozSelectSize; select: boolean; }>; readonly classes: _angular_core.Signal<{ 'select--control': boolean; 'select--readonly': boolean; 'is-invalid': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozStatusBadgeStatus = 'info' | 'success' | 'warning' | 'error' | 'neutral'; declare class MozStatusBadgeComponent { readonly label: _angular_core.InputSignal; readonly status: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozStatusBadgeStatus; 'mc-status-badge': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozStatusDotStatus = 'info' | 'success' | 'warning' | 'error' | 'neutral'; type MozStatusDotSize = 's' | 'm' | 'l'; declare class MozStatusDotComponent { readonly status: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozStatusDotStatus | MozStatusDotSize; 'mc-status-dot': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozStatusNotificationStatus = 'info' | 'success' | 'warning' | 'error'; declare class MozStatusNotificationComponent { readonly id: _angular_core.InputSignal; readonly title: _angular_core.InputSignal; readonly status: _angular_core.InputSignal; readonly closable: _angular_core.InputSignal; readonly closed: _angular_core.OutputEmitterRef; readonly descriptionTpl: Signal | undefined>; readonly footerTpl: Signal | undefined>; readonly classes: Signal<{ [x: string]: boolean | MozStatusNotificationStatus; 'mc-status-notification': boolean; }>; readonly iconComponent: Signal>; onCloseClick(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozTabComponent { id: _angular_core.InputSignal; label: _angular_core.InputSignal; icon: _angular_core.InputSignal | undefined>; disabled: _angular_core.InputSignal; routerLink: _angular_core.InputSignal; badge: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface MozTabItem { id: string; label: string; icon?: Type; disabled?: boolean; routerLink?: string; badge?: number | string; } declare class MozTabsComponent implements AfterContentInit { tabs: QueryList; description: _angular_core.InputSignal; divider: _angular_core.InputSignal; centered: _angular_core.InputSignal; selectedIndex: _angular_core.ModelSignal; tabsInput: _angular_core.InputSignal; selectedIndexChange: EventEmitter; tabsArray: _angular_core.WritableSignal; virtualTabs: _angular_core.WritableSignal; constructor(); ngAfterContentInit(): void; hasVirtualTabs: _angular_core.Signal; readonly classes: _angular_core.Signal<{ tabs: boolean; 'tabs--centered': boolean; }>; isTabSelected: (index: number) => boolean; getTabClasses(index: number): _angular_core.Signal<{ tabs__tab: boolean; 'tabs__tab--selected': boolean; 'tabs__tab--disabled': boolean; }>; getVirtualTabClasses(index: number): _angular_core.Signal<{ tabs__tab: boolean; 'tabs__tab--selected': boolean; 'tabs__tab--disabled': boolean; }>; onClickTab(index: number): void; onClickVirtualTab(index: number, tab: MozTabItem): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTagType = 'informative' | 'interactive' | 'contextualised' | 'removable' | 'selectable'; type MozTagSize = 's' | 'm' | 'l'; declare class MozTagComponent implements ControlValueAccessor { readonly type: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly contextualisedNumber: _angular_core.InputSignal; readonly removableLabel: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; readonly removeTag: _angular_core.OutputEmitterRef; readonly classes: _angular_core.Signal<{ [x: string]: MozTagType | MozTagSize; }>; private onChange; private onTouched; writeValue(value: boolean): void; registerOnChange(fn: (value: boolean) => void): void; registerOnTouched(fn: () => void): void; onCheckboxChange(event: Event): void; onRemove(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Directive that transforms a simple textarea into a styled textarea. * Applies Mozaic Design System styles to native textarea elements. */ declare class MozTextarea implements ControlValueAccessor, AfterViewInit, OnDestroy { private elementRef; private renderer; readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly rows: _angular_core.InputSignal; readonly minLength: _angular_core.InputSignal; readonly maxLength: _angular_core.InputSignal; private _value; private _isDisabled; readonly isDisabledState: _angular_core.Signal; onChange: (value: string) => void; onTouched: () => void; constructor(elementRef: ElementRef, renderer: Renderer2); ngAfterViewInit(): void; ngOnDestroy(): void; private applyAttributes; handleInput(event: Event): void; writeValue(value: string): void; registerOnChange(fn: (value: string) => void): void; registerOnTouched(fn: () => void): void; setDisabledState(isDisabled: boolean): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTextInputSize = 's' | 'm'; declare class MozTextInput implements ControlValueAccessor, AfterViewInit, OnDestroy { readonly isInvalid: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly readonly: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly clearable: _angular_core.InputSignal; readonly clearLabel: _angular_core.InputSignal; readonly prefix: _angular_core.InputSignal; readonly suffix: _angular_core.InputSignal; private wrapper; private clearButton; private iconContainer; private iconComponentRef; private _value; private _isDisabled; readonly isClearable: _angular_core.Signal; readonly isDisabledState: _angular_core.Signal; private environmentInjector; private applicationRef; private renderer; private elementRef; private injector; ngAfterViewInit(): void; ngOnDestroy(): void; private setupEffects; private wrapInput; private createAddon; private findIconElement; private createIconContainer; private createClearButton; private updateClearButtonVisibility; clearValue(): void; onInput(event: Event): void; onChange: (value: string | number) => void; onTouched: () => void; writeValue(value: string | number): void; registerOnChange(fn: (value: string | number) => void): void; registerOnTouched(fn: () => void): void; setDisabledState(isDisabled: boolean): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozToggleSize = 's' | 'm'; declare class MozToggleComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean | MozToggleSize; toggle: boolean; }>; _value: _angular_core.WritableSignal; onChange: (_: boolean) => void; onTouched: () => void; writeValue(value: boolean): void; registerOnChange(fn: (value: boolean) => void): void; registerOnTouched(fn: () => void): void; onInputChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozFlagType = 'default' | 'accent' | 'danger' | 'inverse'; declare class MozFlagComponent { readonly type: _angular_core.InputSignal; readonly classes: _angular_core.Signal<"flag" | "flag flag--accent" | "flag flag--danger" | "flag flag--inverse">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozDatepickerSize = 'default' | 's'; declare class MozDatepickerComponent implements ControlValueAccessor { readonly id: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly readonly: _angular_core.InputSignal; readonly invalid: _angular_core.InputSignal; readonly error: _angular_core.InputSignal; readonly clearable: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; readonly _value: _angular_core.WritableSignal; readonly classes: _angular_core.Signal<{ 'mc-datepicker': boolean; 'mc-text-input': boolean; 'is-invalid': boolean; 'mc-datepicker--s': boolean; 'mc-text-input--s': boolean; }>; private onChange; private onTouched; writeValue(val: string | null): void; registerOnChange(fn: (val: string | null) => void): void; registerOnTouched(fn: () => void): void; onInput(event: Event): void; onClear(): void; onBlur(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTooltipPosition = 'top' | 'bottom' | 'left' | 'right'; declare class MozTooltipComponent { readonly id: _angular_core.InputSignal; readonly position: _angular_core.InputSignal; readonly noPointer: _angular_core.InputSignal; readonly standalone: _angular_core.InputSignal; content: string; readonly classes: _angular_core.Signal<{ [x: string]: boolean; tooltip: boolean; 'tooltip--no-pointer': boolean; 'tooltip--standalone': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozTooltipDirective implements OnDestroy { content: string; tooltipPosition: MozTooltipPosition; tooltipNoPointer: boolean; private overlayRef; private overlay; private overlayPositionBuilder; private elementRef; show(): void; hide(): void; ngOnDestroy(): void; private getPositions; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } type MozCircularProgessBarSize = 's' | 'm' | 'l'; declare class MozCircularProgressBarComponent { readonly valuePercent: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly ariaLabel: _angular_core.InputSignal; readonly numberLabel: _angular_core.InputSignal; readonly textLabel: _angular_core.InputSignal; readonly showPercentage: _angular_core.InputSignal; readonly classes: _angular_core.Signal; readonly hasNumberOrText: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozLinearProgressBarBufferSize = 's' | 'm' | 'l'; declare class MozLinearProgressBarBufferComponent { readonly valuePercent: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly ariaLabel: _angular_core.InputSignal; readonly classes: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozLinearProgressBarPercentageComponent { readonly valuePercent: _angular_core.InputSignal; readonly ariaLabel: _angular_core.InputSignal; readonly showLabel: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozCalloutVariant = 'default' | 'inverse' | 'tips' | 'accent'; declare class MozCalloutComponent { readonly title: _angular_core.InputSignal; readonly message: _angular_core.InputSignal; readonly role: _angular_core.InputSignal; readonly variant: _angular_core.InputSignal; readonly footerTpl: _angular_core.Signal | undefined>; readonly classes: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozAvatarSize = 's' | 'm' | 'l'; declare class MozAvatarComponent { readonly size: _angular_core.InputSignal; readonly classes: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozPhoneNumberCountry = { code: string; name: string; dialCode: string; }; type MozPhoneNumberValue = { country: string; number: string; }; type MozPhoneNumberSize = 's' | 'm'; declare class MozPhoneNumberComponent implements ControlValueAccessor { readonly label: _angular_core.InputSignal; readonly requirementText: _angular_core.InputSignal; readonly showRequirement: _angular_core.InputSignalWithTransform; readonly helpText: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly placeholder: _angular_core.InputSignal; readonly defaultCountry: _angular_core.InputSignal; readonly locale: _angular_core.InputSignal; readonly countryCodes: _angular_core.InputSignal; readonly countries: _angular_core.InputSignal; readonly showCountrySelect: _angular_core.InputSignalWithTransform; readonly showCountryCode: _angular_core.InputSignalWithTransform; readonly disabled: _angular_core.InputSignalWithTransform; readonly readonly: _angular_core.InputSignalWithTransform; readonly invalid: _angular_core.InputSignal; readonly errorMessage: _angular_core.InputSignal; readonly selectName: _angular_core.InputSignal; readonly inputName: _angular_core.InputSignal; private readonly _country; private readonly _number; private readonly uid; readonly selectId: string; readonly flagImgId: string; readonly inputId: string; readonly helpId: string; readonly errorId: string; readonly ccId: string; readonly selectedCountryCode: _angular_core.Signal; readonly availableCountries: _angular_core.Signal; readonly selectedCountryName: _angular_core.Signal; readonly selectedDialCode: _angular_core.Signal; readonly selectedFlagUrl: _angular_core.Signal; readonly number: _angular_core.Signal; readonly dynamicPlaceholder: _angular_core.Signal; private selectedLibCountryCode; private parsedNumber; private phoneIsValid; getCountryName(countryCode: string): string; getCountryCallingCodeFor(countryCode: string): string; describedBy: _angular_core.Signal; private formInvalid; private formErrorMsg; isInvalid: _angular_core.Signal; errorToShow: _angular_core.Signal; private onChange?; onTouched?: () => void; writeValue(value: MozPhoneNumberValue | null): void; registerOnChange(fn: (value: MozPhoneNumberValue) => void): void; registerOnTouched(fn: () => void): void; onCountryChange(code: string): void; onNumberChange(val: string): void; private emitChange; private sanitize; setFormInvalidState(invalid: boolean, message?: string | null): void; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozToasterStatus = 'info' | 'success' | 'warning' | 'error'; type MozToasterPosition = 'top' | 'bottom' | 'top-center' | 'bottom-center'; type MozToasterRole = 'status' | 'alert'; declare class MozToasterComponent implements AfterContentInit { readonly open: _angular_core.InputSignalWithTransform; readonly position: _angular_core.InputSignal; readonly description: _angular_core.InputSignal; readonly status: _angular_core.InputSignal; readonly closable: _angular_core.InputSignalWithTransform; readonly progress: _angular_core.InputSignalWithTransform; readonly timeout: _angular_core.InputSignal; readonly role: _angular_core.InputSignal; readonly closeAriaLabel: _angular_core.InputSignal; readonly openChange: _angular_core.OutputEmitterRef; readonly closed: _angular_core.OutputEmitterRef; readonly actionSlot: _angular_core.Signal | undefined>; readonly hasAction: _angular_core.WritableSignal; ngAfterContentInit(): void; classes: _angular_core.Signal; private _progressValue; progressValue: () => number; private intervalId; private timeoutId; private startAt; constructor(); onCloseClick(): void; private clearTimers; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface MozToasterConfig { open?: boolean; position?: MozToasterPosition; description: string; status?: MozToasterStatus; closable?: boolean; progress?: boolean; timeout?: number | null; role?: MozToasterRole; closeAriaLabel?: string; } declare const TOASTER_CONFIG: InjectionToken; declare const DEFAULT_TOASTER_CONFIG: Partial; declare class MozToasterRef { private readonly overlayRef; private readonly afterClosed$; private readonly afterOpened$; readonly isOpen: _angular_core.WritableSignal; readonly description: _angular_core.WritableSignal; readonly status: _angular_core.WritableSignal; readonly closable: _angular_core.WritableSignal; readonly timeout: _angular_core.WritableSignal; readonly progress: _angular_core.WritableSignal; readonly position: _angular_core.WritableSignal; private animationDuration; constructor(overlayRef: OverlayRef); open(): void; close(): void; afterClosed(): Observable; afterOpened(): Observable; } declare class MozToasterService { private readonly overlay; private readonly injector; open(config: MozToasterConfig): MozToasterRef; private createOverlay; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } type MozSidebarSubItem = { id: string; label: string; href?: string; selected?: boolean; }; type MozSidebarItem = { id: string; label: string; icon?: Type; href?: string; selected?: boolean; open?: boolean; children?: MozSidebarSubItem[]; }; declare class MozSidebarComponent { readonly expanded: _angular_core.InputSignalWithTransform; readonly items: _angular_core.InputSignal; readonly title: _angular_core.InputSignal; readonly logoSrc: _angular_core.InputSignal; readonly logoAlt: _angular_core.InputSignal; readonly showFooter: _angular_core.InputSignalWithTransform; readonly showProfile: _angular_core.InputSignalWithTransform; readonly profileName: _angular_core.InputSignal; readonly profileTitle: _angular_core.InputSignal; readonly profileAvatarSrc: _angular_core.InputSignal; readonly expandedChange: _angular_core.OutputEmitterRef; readonly itemClick: _angular_core.OutputEmitterRef<{ itemId: string; subItemId: string | null; }>; readonly hostClasses: _angular_core.Signal; readonly expandButtonAriaLabel: _angular_core.Signal<"Collapse" | "Expand">; shouldOpen: (i: MozSidebarItem) => boolean; toggleExpanded(): void; onItemClick(itemId: string, subItemId: string | null, ev: Event): void; toggleOpen(item: MozSidebarItem): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozSegmentedControlSize = 's' | 'm'; type MozSegmentedItem = { label: string; value: string | number; disabled?: boolean; }; declare class MozSegmentedControlComponent { readonly items: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly full: _angular_core.InputSignalWithTransform; readonly disabled: _angular_core.InputSignalWithTransform; readonly ariaLabel: _angular_core.InputSignal; readonly selectedIndex: _angular_core.ModelSignal; readonly change: _angular_core.OutputEmitterRef<{ index: number; value: string | number; }>; readonly classes: _angular_core.Signal<{ 'segmented-control': boolean; 'segmented-control--disabled': boolean; 'segmented-control--m': boolean; 'segmented-control--full': boolean; }>; readonly segmentClasses: (index: number) => _angular_core.Signal<{ 'segmented-control__segment--disabled': boolean; 'segmented-control__segment': boolean; 'segmented-control__segment--selected': boolean; }>; private readonly buttons; onSelect(index: number): void; private focusIndex; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozAccordionHeaderComponent { readonly tpl: _angular_core.Signal | undefined>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozAccordionContentComponent { readonly tpl: _angular_core.Signal | undefined>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozAccordionPanelComponent { readonly icon: _angular_core.InputSignal | null>; readonly open: _angular_core.InputSignal; readonly state: _angular_core.WritableSignal; readonly header: _angular_core.Signal; readonly content: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Accordion component for organizing content in collapsible sections. * * @description * The accordion component allows users to show and hide sections of content. * Each section consists of a header and content area that can be expanded or collapsed. * Supports both custom and native HTML implementation. * * @example * ```html * * * * Panel Title * Panel Subtitle * * *

Panel content goes here

* * * * ``` */ declare class MozAccordionComponent { /** * Applies ghost styling to the accordion for a lighter visual appearance. * Useful for nested or secondary accordions. * * @default false */ readonly ghost: _angular_core.InputSignal; /** * Uses native HTML `
` and `` elements instead of custom implementation. * Provides better accessibility and performance with browser-native behavior. * * @default false */ readonly native: _angular_core.InputSignal; /** * Computed CSS classes based on component inputs. * Automatically updates when ghost input changes. * * @internal */ readonly cssClasses: _angular_core.Signal<{ accordion: boolean; 'accordion--ghost': boolean; }>; /** * Signal containing all accordion panels projected into this component. * Automatically synchronized with content children. * * @internal */ readonly panels: _angular_core.Signal; /** * Toggles the open/closed state of an accordion panel. * * @param p - The accordion panel to toggle */ toggle(p: MozAccordionPanelComponent): void; /** * Handles the native toggle event for accordion panels using HTML details/summary. * Synchronizes the panel state with the native element's open state. * * @param ev - The native toggle event * @param p - The accordion panel being toggled */ onNativeToggle(ev: Event, p: MozAccordionPanelComponent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozActionBottomBarComponent { readonly boxShadow: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ 'mc-action-bottom-bar': boolean; 'mc-action-bottom-bar--shadow': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozActionListItemAppearance = 'standard' | 'danger'; interface MozActionListItem { /** * The unique identifier for the item. */ id: string; /** * The icon component displayed for the item. */ icon?: Type; /** * The label displayed for the item. */ label: string; /** * If `true`, the item will be disabled. */ disabled?: boolean; /** * Allows to define the item appearance. */ appearance?: MozActionListItemAppearance; /** * Add a divider on top of the item. */ divider?: boolean; } /** * An action list is a contextual menu that presents a list of available actions related to a specific element or interface area. * It allows users to quickly access functions such as editing, sharing, deleting, or navigating to sub-actions. * Action Lists are commonly triggered by buttons, icons (e.g., three-dot menus), or right-click interactions, ensuring a clean and efficient UI. */ declare class MozActionListboxComponent { /** * Title displayed in mobile version. */ readonly title: _angular_core.InputSignal; /** * An array of objects that allows you to provide all the data needed to generate the content for each item. */ readonly items: _angular_core.InputSignal; /** * Emitted when an item is clicked. */ readonly itemClick: _angular_core.OutputEmitterRef; /** * Computed signal that maps items to their CSS classes. */ readonly itemsWithClasses: _angular_core.Signal<{ item: MozActionListItem; classes: { 'action-list__element': boolean; 'action-list__element--danger': boolean; 'action-list__element--disabled': boolean; }; }[]>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type ActionListboxPosition = 'below' | 'above' | 'before' | 'after'; interface ActionListboxConfig { items: MozActionListItem[]; title?: string; position?: ActionListboxPosition; hasBackdrop?: boolean; } declare const ACTION_LISTBOX_CONFIG: InjectionToken; declare const DEFAULT_ACTION_LISTBOX_CONFIG: Omit, 'items'>; declare class ActionListboxContainerComponent { readonly config: ActionListboxConfig; private readonly listboxRef; onItemClick(item: MozActionListItem): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozActionListboxTriggerDirective implements OnDestroy { private readonly overlay; private readonly elementRef; private readonly injector; /** The list of items to display */ readonly mozActionListboxTrigger: _angular_core.InputSignal; /** Optional title for the listbox */ readonly actionListboxTitle: _angular_core.InputSignal; /** Position relative to the trigger element */ readonly actionListboxPosition: _angular_core.InputSignal; /** Emits the clicked item */ readonly itemClick: _angular_core.OutputEmitterRef; private listboxRef; toggle(): void; open(): void; close(): void; ngOnDestroy(): void; private createOverlay; private getPositions; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class ActionListboxRef { private readonly overlayRef; private readonly afterClosed$; private readonly itemClicked$; constructor(overlayRef: OverlayRef); close(): void; selectItem(item: MozActionListItem): void; afterClosed(): Observable; onItemClick(): Observable; } declare class MozCarouselComponent implements OnDestroy { readonly ariaLabelledby: _angular_core.InputSignal; readonly previousButtonAriaLabel: _angular_core.InputSignal; readonly nextButtonAriaLabel: _angular_core.InputSignal; readonly index: _angular_core.ModelSignal; private readonly contentEl; private metrics; private raf; private cleanup; private eps; readonly canPrev: _angular_core.Signal; readonly canNext: _angular_core.Signal; private updateLogicalIndexFromScroll; constructor(); ngOnDestroy(): void; goPrevious(): void; goNext(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozStatusMessageStatus = 'info' | 'success' | 'warning' | 'error' | 'neutral' | 'inprogress'; declare class MozStatusMessageComponent { readonly status: _angular_core.InputSignal; readonly description: _angular_core.InputSignal; readonly id: _angular_core.InputSignal; readonly classes: Signal<{ [x: string]: boolean | MozStatusMessageStatus; 'mc-status-message': boolean; }>; readonly iconComponent: Signal>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozKpiTrend = 'increasing' | 'decreasing' | 'stable'; type MozKpiStatus = 'info' | 'warning' | 'error' | 'success' | 'neutral'; type MozKpiSize = 's' | 'm' | 'l'; declare class MozKpiComponent { /** The current value of the KPI item. */ readonly value: _angular_core.InputSignal; /** Defines the evolution of the KPI. */ readonly trend: _angular_core.InputSignal; /** Label of the KPI item. */ readonly label: _angular_core.InputSignal; /** Allows to define the KPI item status. */ readonly status: _angular_core.InputSignal; /** The evolution information defining the KPI. */ readonly information: _angular_core.InputSignal; /** Allows to define the KPI item size. */ readonly size: _angular_core.InputSignal; readonly isMedium: _angular_core.Signal; readonly isLarge: _angular_core.Signal; readonly rootClasses: _angular_core.Signal<{ kpi: boolean; 'kpi--s': boolean; 'kpi--m': boolean; 'kpi--l': boolean; 'kpi--info': boolean; 'kpi--warning': boolean; 'kpi--error': boolean; 'kpi--success': boolean; 'kpi--neutral': boolean; }>; private readonly iconMap; readonly IconComponent: _angular_core.Signal | null>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozStepperCompactComponent { value: _angular_core.InputSignal; maxSteps: _angular_core.InputSignal; label: _angular_core.InputSignal; description: _angular_core.InputSignal; readonly hasLabel: _angular_core.Signal; readonly safeMaxSteps: _angular_core.Signal; readonly progressPercentage: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozStarRatingSize = 's' | 'm' | 'l'; type MozStarRatingAppearance = 'standard' | 'accent'; declare class MozStarRatingComponent { /** * The current rating value of the component. * Used with two-way binding [(value)]. * When the rating changes (via click or keyboard), the model is automatically updated. */ readonly value: _angular_core.ModelSignal; /** * Determines whether the rating is interactive or read-only. * When true, all user interactions (click, hover, keyboard) are disabled. * Automatically set to true when `compact`, `href`, or `text` are provided. */ readonly readonly: _angular_core.InputSignal; /** * Enables a compact display mode that shows only one star instead of five. * Typically used for summaries or quick visual cues. * When enabled, the component automatically becomes read-only. */ readonly compact: _angular_core.InputSignal; /** * Defines the visual size of the star icons and the accompanying text. */ readonly size: _angular_core.InputSignal; /** * Specifies the color scheme of the stars. */ readonly appearance: _angular_core.InputSignal; /** * Optional text displayed next to the star rating. * If provided, the component automatically becomes read-only. */ readonly text: _angular_core.InputSignal; /** * URL for the link (for external links). */ readonly href: _angular_core.InputSignal; /** * Where to open the link. */ readonly target: _angular_core.InputSignal; readonly maxValue: _angular_core.Signal<1 | 5>; readonly isReadonly: _angular_core.Signal; readonly hasInfoText: _angular_core.Signal; readonly ariaLabel: _angular_core.Signal; readonly stars: _angular_core.Signal; readonly classes: _angular_core.Signal<{ 'star-rating': boolean; 'star-rating--link': boolean; 'star-rating--slider': boolean; 'star-rating--s': boolean; 'star-rating--m': boolean; 'star-rating--l': boolean; 'star-rating--standard': boolean; 'star-rating--accent': boolean; }>; private readonly iconMaps; private hoverValue; /** * valeur réellement utilisée pour afficher les étoiles : * - en readonly : toujours value() * - en interactif : hoverValue si non nul, sinon value() */ readonly displayValue: _angular_core.Signal; private clampValue; /** JS: onClick(index) -> setValue(index+1) + updateStarIcons */ onStarClick(index: number): void; /** JS: onHover(index) -> hoverValue=index+1 + updateStarIcons(hoverValue) */ onStarMouseMove(index: number): void; /** JS: resetHoverValue() -> hoverValue=null + updateStarIcons(value) */ clearHover(): void; /** JS: onKeydown (ArrowRight / ArrowLeft) */ onWrapperKeydown(event: KeyboardEvent): void; getStarComponent(index: number): Type; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozBuiltInMenuItemTarget = '_self' | '_blank' | '_parent' | '_top'; type MozBuiltInMenuItem = { label: string; icon?: Type; href?: string; routerLink?: string | unknown[]; target?: MozBuiltInMenuItemTarget; }; /** * A built-in menu is a structured list of navigational or interactive options, * typically displayed as a vertical stack. */ declare class BuiltInMenuComponent { /** * Items displayed in the menu. */ readonly items: _angular_core.InputSignal; /** * Index of the currently selected menu item. * Used with two-way binding: [(selectedIndex)]. */ readonly selectedIndex: _angular_core.ModelSignal; /** * When enabled, adds a visible border around the wrapper. */ readonly outlined: _angular_core.InputSignal; /** * Accessible label for the navigation. */ readonly ariaLabel: _angular_core.InputSignal; readonly hostClasses: _angular_core.Signal; isSelected(index: number): boolean; onItemClick(index: number, event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A check-list menu is a structured vertical list where each item represents a distinct section of content. * It wraps moz-built-in-menu and adds a visual checked state using an icon. */ type MozCheckListMenuItem = Omit & { checked: boolean; }; declare class MozCheckListMenuComponent { /** * Defines the menu items, each of which sets a checked state and can act as a button or link. */ readonly items: _angular_core.InputSignal; /** * When enabled, adds a visible border around the wrapper. */ readonly outlined: _angular_core.InputSignal; /** * Currently selected item index (two-way bindable with [(selectedIndex)]). */ readonly selectedIndex: _angular_core.ModelSignal; /** * Internal mapping to BuiltInMenuItem with an icon for checked items. */ readonly menuItems: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A stepper is a navigation component that guides users through a sequence of steps * in a structured process. It visually represents progress, completed steps, and * upcoming steps, helping users understand their position within a workflow. */ interface MozStepperInlineStep { /** * Label of the step. */ label: string; /** * Optional additional information under the label. */ additionalInfo?: string; } declare class MozStepperInlineComponent { /** * Current step of the stepper inline (1-based index). */ readonly currentStep: _angular_core.InputSignal; /** * Steps of the stepper inline. */ readonly steps: _angular_core.InputSignal; /** * Clamped current step between 1 and steps.length. */ readonly safeStep: _angular_core.Signal; /** * Derived state for each step: completed / current. */ readonly stepStates: _angular_core.Signal<{ completed: boolean; current: boolean; }[]>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * A stepper is a navigation component that guides users through a sequence of steps * in a structured process. It visually represents progress, completed steps, and * upcoming steps, helping users understand their position within a workflow. */ interface MozStepperStackedStep { /** * Label of the step. */ label: string; /** * Optional additional information under the label. */ additionalInfo?: string; /** * Optional unique identifier for the step. When omitted, the component * auto-generates one as `{componentId}-step-{index}` (0-based). * Useful for ARIA `aria-controls`, deep-link anchors or e2e selectors. */ id?: string; } declare class MozStepperStackedComponent { /** * Optional prefix used to build auto-generated step IDs when a step * doesn't provide its own `id`. Defaults to a unique `moz-stepper-N`. * Override this when multiple steppers share the same page so their * auto-generated IDs don't collide. */ readonly componentId: _angular_core.InputSignal; /** * Current step of the stepper stacked (1-based index). */ readonly currentStep: _angular_core.InputSignal; /** * Steps of the stepper stacked. */ readonly steps: _angular_core.InputSignal; /** * Clamped current step between 1 and steps.length. */ readonly safeStep: _angular_core.Signal; /** * Whether all steps are completed (currentStep exceeds the number of steps). */ readonly allCompleted: _angular_core.Signal; /** * Derived state for each step: completed / current. */ readonly stepStates: _angular_core.Signal<{ completed: boolean; current: boolean; }[]>; /** * Returns the resolved ID for the step at index `i`: the explicit * `step.id` if provided, otherwise an auto-generated stable value. */ stepId(step: MozStepperStackedStep, i: number): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Step position in the stepper workflow. */ type MozStepperBottomBarStep = 'start' | 'middle' | 'end'; /** * Stepper Bottom Bar component for navigation in multi-step processes. * * @description * The stepper bottom bar provides navigation controls for multi-step workflows, * with cancel, previous, next, and validate buttons that adapt based on the current step. */ declare class MozStepperBottomBarComponent { /** * Base ID for the stepper component. */ id: _angular_core.InputSignal; /** * Step of the process. */ step: _angular_core.InputSignal; /** * If `true`, display the cancel button. */ hasCancel: _angular_core.InputSignal; /** * Text for the cancel button. */ cancelText: _angular_core.InputSignal; /** * Text for the previous button. */ previousText: _angular_core.InputSignal; /** * Text for the next button. */ nextText: _angular_core.InputSignal; /** * Text for the validate button. */ validateText: _angular_core.InputSignal; /** * If `true`, disable the next button. */ disabledNext: _angular_core.InputSignal; /** * Event emitted when cancel button is clicked. */ cancel: _angular_core.OutputEmitterRef; /** * Event emitted when previous button is clicked. */ previous: _angular_core.OutputEmitterRef; /** * Event emitted when next button is clicked. */ next: _angular_core.OutputEmitterRef; /** * Event emitted when validate button is clicked. */ validate: _angular_core.OutputEmitterRef; handleCancel(): void; handlePrevious(): void; handleNext(): void; handleValidate(): void; /** * Computed IDs for buttons */ cancelButtonId: _angular_core.Signal; cancelButtonIconId: _angular_core.Signal; previousButtonId: _angular_core.Signal; previousButtonIconId: _angular_core.Signal; nextButtonId: _angular_core.Signal; nextButtonIconId: _angular_core.Signal; validateButtonId: _angular_core.Signal; validateButtonIconId: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface MozPageHeaderScope { id?: string; text: string; value: string | number; attributes?: Record; disabled?: boolean; } declare class MozPageHeaderComponent { readonly title: _angular_core.InputSignal; readonly shadow: _angular_core.InputSignal; readonly backButton: _angular_core.InputSignal; readonly searchButton: _angular_core.InputSignal; readonly helpButton: _angular_core.InputSignal; readonly notificationButton: _angular_core.InputSignal; readonly status: _angular_core.InputSignal; readonly statusLabel: _angular_core.InputSignal; readonly extraInfo: _angular_core.InputSignal; readonly scope: _angular_core.InputSignal; readonly scopeValue: _angular_core.InputSignal; readonly scopePlaceholder: _angular_core.InputSignal; readonly tabs: _angular_core.InputSignal; readonly activeTab: _angular_core.ModelSignal; readonly back: _angular_core.OutputEmitterRef; readonly search: _angular_core.OutputEmitterRef; readonly help: _angular_core.OutputEmitterRef; readonly notification: _angular_core.OutputEmitterRef; readonly toggleMenu: _angular_core.OutputEmitterRef; readonly toggleScope: _angular_core.OutputEmitterRef; readonly scopeValueChange: _angular_core.OutputEmitterRef; readonly activeTabChange: _angular_core.OutputEmitterRef; readonly classes: _angular_core.Signal<{ 'mc-page-header': boolean; 'mc-page-header--with-shadow': boolean; }>; readonly isScopeString: _angular_core.Signal; readonly isScopeArray: _angular_core.Signal; readonly isScopeValueBoolean: _angular_core.Signal; readonly isScopeValueNotBoolean: _angular_core.Signal; readonly hasStatusOrExtraInfo: _angular_core.Signal; readonly hasStatusBadge: _angular_core.Signal<"" | MozStatusBadgeStatus | undefined>; readonly hasIconButtons: _angular_core.Signal; readonly scopeAsArray: _angular_core.Signal; readonly mobileTagLabel: _angular_core.Signal; onBack(): void; onSearch(): void; onHelp(): void; onNotification(): void; onToggleMenu(): void; onToggleScope(): void; onScopeTagClick(): void; onScopeSelectChange(value: string | number): void; onActiveTabChange(index: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTileAppearance = 'primary' | 'secondary' | 'inverse'; declare class MozTileComponent { readonly appearance: _angular_core.InputSignal; readonly isBordered: _angular_core.InputSignal; readonly extraAction: _angular_core.InputSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean; 'mc-tile': boolean; 'mc-tile--bordered': boolean; }>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTileSelectableType = 'checkbox' | 'radio'; type MozTileInputVerticalPosition = 'top' | 'center'; type MozTileInputPosition = 'left' | 'right'; type MozTileSelectableAppearance = 'primary'; declare class MozTileSelectableComponent implements ControlValueAccessor { readonly appearance: _angular_core.InputSignal<"primary">; readonly bordered: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly checked: _angular_core.InputSignal; readonly disabled: _angular_core.InputSignal; readonly inputVerticalPosition: _angular_core.InputSignal; readonly inputPosition: _angular_core.InputSignal; readonly inputType: _angular_core.InputSignal; private readonly innerValue; private readonly isControlledByForm; private onTouchedCallback; private onChangeCallback; constructor(); protected readonly isCheckbox: _angular_core.Signal; protected readonly isRadio: _angular_core.Signal; protected readonly isChecked: _angular_core.Signal; protected readonly classes: _angular_core.Signal; writeValue(value: boolean | string): void; registerOnChange(fn: (value: boolean | string) => void): void; registerOnTouched(fn: () => void): void; onTileChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozTileExpandableTrigger = 'container' | 'button' | 'icon'; declare class MozTileExpandableComponent { readonly triggerMode: _angular_core.InputSignal; readonly id: _angular_core.InputSignal; readonly expanded: _angular_core.WritableSignal; readonly contentId: string; readonly isContainerTrigger: _angular_core.Signal; readonly isIconTrigger: _angular_core.Signal; readonly isButtonTrigger: _angular_core.Signal; readonly toggle: () => void; readonly hostClass: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozDrawerPosition = 'left' | 'right'; interface MozDrawerConfig { title: string; contentTitle?: string; position?: MozDrawerPosition; extended?: boolean; back?: boolean; panelClass?: string; data?: D; } declare const DRAWER_CONFIG: InjectionToken>; declare const DRAWER_DATA: InjectionToken; declare class MozDrawerRef { private readonly overlayRef; private readonly afterClosed$; private readonly afterOpened$; private readonly backClicked$; readonly isOpen: _angular_core.WritableSignal; readonly title: _angular_core.WritableSignal; readonly contentTitle: _angular_core.WritableSignal; readonly position: _angular_core.WritableSignal; readonly extended: _angular_core.WritableSignal; readonly back: _angular_core.WritableSignal; readonly panelClass: _angular_core.WritableSignal; private animationDuration; constructor(overlayRef: OverlayRef); open(): void; close(result?: R): void; backClick(): void; afterClosed(): Observable; afterOpened(): Observable; onBackClick(): Observable; } declare class MozDrawerService { private readonly overlay; private readonly injector; open(component: Type, config: MozDrawerConfig): MozDrawerRef; private createOverlay; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class MozDrawerFooterDirective { private readonly tpl; private readonly container; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class DrawerContainerComponent { readonly drawerRef: MozDrawerRef; readonly config: MozDrawerConfig; readonly portalOutlet: _angular_core.Signal; footerTpl: TemplateRef | null; private componentRef; readonly classes: _angular_core.Signal<{ [x: string]: boolean; 'mc-drawer': boolean; 'is-open': boolean; 'mc-drawer--extend': boolean; }>; readonly dialogClasses: _angular_core.Signal; readonly ariaModal: _angular_core.Signal<"true" | "false">; attachComponent(component: Type): ComponentRef; registerFooter(tpl: TemplateRef): void; noop(): void; onBackClick(): void; onBackdropClick(event: MouseEvent): void; onEscape(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozDrawerComponent { readonly open: _angular_core.InputSignal; readonly position: _angular_core.InputSignal; readonly extended: _angular_core.InputSignal; readonly back: _angular_core.InputSignal; readonly title: _angular_core.InputSignal; readonly contentTitle: _angular_core.InputSignal; readonly panelClass: _angular_core.InputSignal; readonly updateOpen: _angular_core.OutputEmitterRef; readonly backEvent: _angular_core.OutputEmitterRef; readonly footerTpl: _angular_core.Signal | undefined>; readonly isOpen: _angular_core.WritableSignal; readonly classes: _angular_core.Signal<{ [x: string]: boolean; 'mc-drawer': boolean; 'is-open': boolean; 'mc-drawer--extend': boolean; }>; readonly dialogClasses: _angular_core.Signal; readonly ariaModal: _angular_core.Signal<"true" | "false">; constructor(); close(): void; backClick(): void; noop(): void; onEscape(): void; onBackdropClick(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type MozPopoverAppearance = 'default' | 'inverse'; type MozPopoverPosition = 'top' | 'bottom' | 'left' | 'right'; type MozPopoverSize = 's' | 'm'; interface PopoverConfig { title?: string; description?: string; appearance?: MozPopoverAppearance; position?: MozPopoverPosition; size?: MozPopoverSize; pointer?: boolean; closable?: boolean; buttonLabel?: string; data?: D; } declare const POPOVER_CONFIG: InjectionToken>; declare const POPOVER_DATA: InjectionToken; declare class MozPopoverComponent { readonly appearance: _angular_core.InputSignal; readonly position: _angular_core.InputSignal; readonly size: _angular_core.InputSignal; readonly pointer: _angular_core.InputSignal; readonly closable: _angular_core.InputSignal; readonly title: _angular_core.InputSignal; readonly description: _angular_core.InputSignal; readonly buttonLabel: _angular_core.InputSignal; readonly open: _angular_core.InputSignal; readonly closeClick: _angular_core.OutputEmitterRef; footerTpl: _angular_core.Signal | undefined>; readonly classMap: _angular_core.Signal<{ [x: string]: boolean; 'mc-popover': boolean; 'mc-popover--inverse': boolean; 'mc-popover--no-pointer': boolean; }>; onClose(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class PopoverRef { private readonly overlayRef; private readonly afterClosed$; private _closed; constructor(overlayRef: OverlayRef); close(result?: R): void; afterClosed(): Observable; } type PopoverTriggerMode = 'click' | 'hover'; declare class MozPopoverTriggerDirective implements OnInit, OnDestroy { private readonly overlay; private readonly elementRef; private readonly injector; private readonly ngZone; /** The component to inject inside the popover, or null for config-only popover */ readonly mozPopoverTrigger: _angular_core.InputSignal | null>; /** Trigger mode: 'click' (default) or 'hover' */ readonly popoverTriggerMode: _angular_core.InputSignal; /** Popover config */ readonly popoverTitle: _angular_core.InputSignal; readonly popoverDescription: _angular_core.InputSignal; readonly popoverAppearance: _angular_core.InputSignal<_mozaic_ds_angular.MozPopoverAppearance | undefined>; readonly popoverPosition: _angular_core.InputSignal; readonly popoverSize: _angular_core.InputSignal<_mozaic_ds_angular.MozPopoverSize | undefined>; readonly popoverPointer: _angular_core.InputSignal; readonly popoverClosable: _angular_core.InputSignal; readonly popoverButtonLabel: _angular_core.InputSignal; readonly popoverData: _angular_core.InputSignal; /** Delay in ms before opening/closing on hover (prevents flicker) */ readonly popoverHoverDelay: _angular_core.InputSignal; /** Emits when popover closes */ readonly popoverClosed: _angular_core.OutputEmitterRef; private popoverRef; private overlayRef; private hoverOpenTimer; private hoverCloseTimer; private overlayMouseEnterHandler; private overlayMouseLeaveHandler; ngOnInit(): void; onHostClick(): void; onHostMouseEnter(): void; onHostMouseLeave(): void; toggle(): void; open(): void; close(): void; ngOnDestroy(): void; private scheduleHoverClose; private cancelHoverClose; private cancelHoverOpen; private attachOverlayHoverListeners; private detachOverlayHoverListeners; private createOverlay; private getPositions; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class PopoverService { private readonly overlay; private readonly injector; /** * Open a popover attached to an element. */ open(component: Type, origin: ElementRef | HTMLElement, config: PopoverConfig): PopoverRef; private createOverlay; private getPositions; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class PopoverContainerComponent { readonly popoverRef: PopoverRef; readonly config: PopoverConfig; private readonly cdr; readonly portalOutlet: _angular_core.Signal; readonly footerTpl: _angular_core.WritableSignal | null>; registerFooter(tpl: TemplateRef): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozPopoverFooterDirective { private readonly tpl; private readonly container; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } type MozNavigationIndicatorAction = 'pause' | 'resume'; declare class MozNavigationIndicatorComponent { /** Total number of steps */ readonly steps: _angular_core.InputSignal; /** Currently active step index (0-based) */ readonly active: _angular_core.ModelSignal; /** Action button type: 'pause' or 'resume' */ readonly action: _angular_core.InputSignal; /** Use light (icon-only) variant for the action button */ readonly light: _angular_core.InputSignal; /** Hide the action button entirely */ readonly hideAction: _angular_core.InputSignal; /** Label for the pause button */ readonly pauseLabel: _angular_core.InputSignal; /** Label for the resume button */ readonly resumeLabel: _angular_core.InputSignal; /** Emits when a step indicator is clicked */ readonly stepClick: _angular_core.OutputEmitterRef; /** Emits when the action button (pause/resume) is clicked */ readonly actionClick: _angular_core.OutputEmitterRef; /** Array of step indices for iteration */ readonly stepsArray: _angular_core.Signal; /** Current action label */ readonly actionLabel: _angular_core.Signal; onStepClick(index: number): void; onActionClick(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface CellCoord { row: number; col: number; } interface CellRange { start: CellCoord; end: CellCoord; } interface CellEditState { editingCell: CellCoord | null; originalValue: unknown; draftValue: unknown; validationError: string | null; } interface CellEditEvent { row: T; rowIndex: number; field: string; oldValue: unknown; newValue: unknown; } interface CellEditCancelEvent { rowIndex: number; field: string; originalValue: unknown; } interface BulkEditEvent { range: CellRange | null; cellCount: number; rowIds: unknown[]; fields: string[]; selectionMode?: 'rows' | 'cells'; rowSelection?: unknown; } interface BulkCopyEvent { range: CellRange | null; data: string[][]; rowIds: unknown[]; fields: string[]; selectionMode?: 'rows' | 'cells'; rowSelection?: unknown; } /** * A single cell change produced by a bulk operation (paste, delete, …). * Values are already coerced to the column's expected type and have passed * `cellEditorValidator`; consumers can persist them as-is. */ interface BulkCellChange { rowIndex: number; rowId: unknown; field: string; oldValue: unknown; newValue: unknown; } interface BulkPasteEvent { range: CellRange | null; data: string[][]; rowIds: unknown[]; fields: string[]; /** * Fully resolved per-cell changes applied by the grid (post-coercion, * post-validation). Use this to persist server-side — no need to replicate * the fill logic from `data` vs `range`. */ changes: BulkCellChange[]; selectionMode?: 'rows' | 'cells'; rowSelection?: unknown; } interface FillDownEvent { sourceCell: CellCoord; sourceValue: unknown; direction: 'vertical' | 'horizontal'; /** Total cells actually written (excludes the anchor and non-editable columns). */ affectedCellCount: number; field?: string; targetRange?: { startRow: number; endRow: number; }; /** @deprecated Use `affectedCellCount` instead. */ affectedRowCount?: number; /** Target columns written in the horizontal fill. Non-editable columns are filtered out. */ targetFields?: string[]; } interface CellError { message: string; } interface BulkDeleteEvent { range: CellRange | null; cellCount: number; rowIds: unknown[]; fields: string[]; /** * Fully resolved per-cell changes applied by the grid (post-coercion, * post-validation). Use this to persist server-side. */ changes: BulkCellChange[]; selectionMode?: 'rows' | 'cells'; rowSelection?: unknown; } /** * Filter model — multi-condition filter builder with AND/OR combinators. * * Evaluation is left-associative (no operator precedence). Grouped / parenthesised * conditions (`(a AND b) OR c`) are out of scope for the MVP; see docs. */ /** Controls where filter evaluation happens. */ type FilterMode = 'client' | 'server'; type FilterDataType = 'text' | 'number' | 'date' | 'set' | 'boolean' | 'custom'; type TextOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank'; type NumberOperator = 'equals' | 'notEquals' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'blank' | 'notBlank'; type DateOperator = NumberOperator; type SetOperator = 'in' | 'notIn' | 'blank' | 'notBlank'; type BooleanOperator = 'equals' | 'blank' | 'notBlank'; type FilterOperator = TextOperator | NumberOperator | DateOperator | SetOperator | BooleanOperator; type FilterCombinator = 'and' | 'or'; interface FilterValue { /** Primary value. Absent / ignored for `blank` / `notBlank`. */ value?: unknown; /** Upper bound for `between`. */ valueTo?: unknown; } interface FilterCondition { /** Stable identifier — used for trackBy and drag-drop reordering. */ id: string; /** Ignored for the first condition. Rendered as "Where" in the UI. */ combinator: FilterCombinator; field: string; operator: FilterOperator; value: FilterValue; } interface FilterModel { conditions: FilterCondition[]; } type FilterChangeReason = 'add' | 'update' | 'remove' | 'reorder' | 'clear' | 'replace'; /** * Payload emitted whenever the filter model changes. Replaces the legacy * `{ filters: ActiveFilter[] }` shape. */ interface FilterEvent { /** Full model after mutation. */ model: FilterModel; /** Condition concerned by the mutation. null for `clear` / `replace`. */ condition: FilterCondition | null; /** Mutation kind. */ reason: FilterChangeReason; } /** Drawer data / result for the Filters drawer (toolbar). */ interface FilterDrawerData { model: FilterModel; availableColumns: FilterColumnDescriptor[]; applyMode: FilterApplyMode; } interface FilterDrawerResult { model: FilterModel; applied: boolean; } type FilterApplyMode = 'auto' | 'manual'; /** * Base class for custom filter components. Extend this class and declare: * readonly condition = input.required(); * readonly conditionChange = output(); * * The filter builder instantiates the component via ViewContainerRef and wires * the inputs/outputs automatically — the component has no dependency on the grid. */ declare abstract class MozGridCustomFilter { abstract readonly condition: InputSignal; abstract readonly conditionChange: OutputEmitterRef; } /** Minimal column info the builder needs to render labels, operators and value editors. */ interface FilterColumnDescriptor { field: string; headerName: string; filterType: FilterDataType; operators: FilterOperator[]; options?: { value: unknown; label: string; }[]; defaultOperator: FilterOperator; /** Custom component rendered in the builder for filterType === 'custom'. */ filterComponent?: Type; /** Override for completion check. Defaults to value.value != null && !== ''. */ filterIsComplete?: (value: FilterValue) => boolean; } /** * Default operator sets per data type. Consumers can restrict the set via * `ColumnDef.filterOperators`. */ declare const DEFAULT_OPERATORS: Record; declare const DEFAULT_OPERATOR_PER_TYPE: Record; /** Human-readable operator labels (used by `toLabel`). */ declare const OPERATOR_LABELS: Record; /** Operators that do not require a user-entered value. */ declare const VALUELESS_OPERATORS: ReadonlySet; /** Operators that need a secondary value (`between`). */ declare const RANGE_OPERATORS: ReadonlySet; /** Small helper for generating condition ids without pulling in a uuid dep. */ declare function generateConditionId(): string; /** True when a condition has enough information to participate in evaluation. */ declare function isConditionComplete(condition: FilterCondition): boolean; type SortDirection = 'asc' | 'desc' | null; type CellEditorType = 'text' | 'number' | 'textarea' | 'select' | 'checkbox' | 'date' | 'toggle' | 'custom'; interface ColumnDef { /** Unique column identifier */ field: string; /** Display name in header */ headerName?: string; /** Fixed width in px (e.g. '120px') */ width?: string; /** Minimum width in px for resize */ minWidth?: string; /** Maximum width in px for resize */ maxWidth?: string; /** Flex grow factor (like CSS flex) */ flex?: number; /** Whether column is sortable */ sortable?: boolean; /** Custom sort comparator */ sortComparator?: (a: T, b: T) => number; /** Whether column is resizable */ resizable?: boolean; /** Whether column is reorderable */ reorderable?: boolean; /** Whether column is groupable */ groupable?: boolean; /** Whether column supports filtering */ filterable?: boolean; /** * Filter data type. When omitted, it is derived from `cellEditor`: * `number → number`, `date → date`, `select → set`, anything else → `text`. */ filterType?: FilterDataType; /** Allowed operators — subset of the defaults for `filterType`. Optional. */ filterOperators?: FilterOperator[]; /** Default operator used when a condition is created for this column. */ defaultFilterOperator?: FilterOperator; /** For `set` filters: the options shown in the value picker. */ filterOptions?: { value: unknown; label: string; }[]; /** Whether column is pinned/frozen ('start' | 'end' | null) */ pinned?: 'start' | 'end' | null; /** Whether column is visible */ visible?: boolean; /** Whether column can be hidden via header menu */ hideable?: boolean; /** Whether column can be frozen via header menu */ freezable?: boolean; /** Whether the column header search (filter input) is visible */ searchVisible?: boolean; /** Disable the header menu entirely for this column */ headerMenuDisabled?: boolean; /** Cell value accessor (alternative to field for nested data) */ valueGetter?: (row: T) => unknown; /** Cell value formatter for display */ valueFormatter?: (value: unknown, row: T) => string; /** CSS class for column cells */ cellClass?: string | ((row: T) => string); /** CSS class for header cell */ headerClass?: string; /** Whether this column supports inline editing (double-click to edit) */ editable?: boolean; /** Editor type — determines which Mozaic component is rendered in edit mode */ cellEditor?: CellEditorType; /** Options for select editors (MozSelectOption[]) */ cellEditorOptions?: MozSelectOption[]; /** Custom validation before commit */ cellEditorValidator?: (value: unknown, row: T) => boolean | string; /** Custom cell template */ cellTemplate?: TemplateRef; /** Custom edit template */ editTemplate?: TemplateRef; /** Custom filter template rendered in the sub-header filter row */ filterTemplate?: TemplateRef; /** * Custom Angular component rendered as the value editor in the filter builder. * The component must extend `MozGridCustomFilter`. * Automatically sets filterType to 'custom'. */ filterComponent?: Type; /** * Client-side predicate used when filterMode="client" and filterType is 'custom'. * If absent, custom conditions are silently skipped in client mode. */ filterPredicate?: (row: T, value: FilterValue) => boolean; /** * Determines whether a custom filter condition is "complete" (has enough data * to participate in evaluation). Defaults to value.value != null && !== ''. */ filterIsComplete?: (value: FilterValue) => boolean; /** Validation function for cell values. Returns CellError or null. */ cellValidator?: (value: unknown, row: T) => CellError | null; /** * Enables spreadsheet-style formulas for this column. Setting this to * `true` implies `editable: true` (users need to type the formula). When * the committed value starts with `=`, it is routed to the `FormulaEngine` * and the evaluated result is rendered in place of the raw formula text. * * Requires the grid-level `formulas` input to be `true` and the row to * expose a stable id via `rowIdField`. */ allowFormula?: boolean; } interface ColumnStateEntry { field: string; currentWidth: number; order: number; visible: boolean; sort: SortDirection; sortIndex: number | null; pinned: 'start' | 'end' | null; searchVisible: boolean; } interface ColumnResizeEvent { field: string; previousWidth: number; newWidth: number; } interface ColumnReorderEvent { field: string; previousIndex: number; newIndex: number; columns: string[]; } interface ColumnFreezeEvent { field: string; side: 'start' | 'end' | null; frozenLeftColumns: string[]; frozenRightColumns: string[]; } interface ColumnVisibilityEvent { field: string; visible: boolean; visibleColumns: string[]; } interface ColumnSearchToggleEvent { field: string; searchVisible: boolean; } type HeaderMenuActionId = 'sort-asc' | 'sort-desc' | 'filter-column' | 'group-column' | 'freeze-column-left' | 'freeze-column-right' | 'unfreeze-column' | 'hide-column' | 'toggle-column-search'; interface HeaderMenuConfig { field: string; columnIndex: number; headerName: string; sortable: boolean; filterable: boolean; groupable: boolean; freezable: boolean; hideable: boolean; searchVisible: boolean; currentSort: SortDirection; } interface SortDef { field: string; direction: SortDirection; priority: number; } interface SortEvent { sorts: SortDef[]; } type LoadingStrategy = 'pagination' | 'infinite-scroll'; interface PaginationState { pageIndex: number; pageSize: number; totalItems: number; totalPages: number; } interface PageEvent { pageIndex: number; pageSize: number; previousPageIndex: number; previousPageSize: number; } interface LoadMoreEvent { offset: number; limit: number; } /** * Lightweight display descriptor for the "FILTERED BY" tag bar. Derived from * the active filter model via `FilterEngine.toLabel()`; kept as a separate * shape so the tag bar template does not depend on the full `FilterCondition`. */ interface ActiveFilter { /** Condition id (not the column field — multiple conditions can target the same field). */ id: string; field: string; label: string; removable: boolean; } interface GroupEvent { columns: string[]; groups: GroupEntry[]; } /** * Emitted when the toolbar export action is triggered while `exportMode` is * `'server'`. The grid does not produce a file itself — the consumer reacts to * this event (e.g. calls a back-end export endpoint) using the active view * descriptors below. */ interface GridExportEvent { format: 'csv'; /** Active sort descriptors at export time. */ sorts: SortDef[]; /** Active filter model at export time. */ filterModel: FilterModel; /** Fields of the currently visible columns, in display order. */ columns: string[]; } interface RowSelectionEvent { selectedIds: unknown[]; excludedIds: unknown[]; selectedRows: T[]; mode: SelectAllMode; count: number; } type SelectAllMode = 'none' | 'page' | 'all'; interface CellSelectionEvent { focusedCell: { row: number; col: number; } | null; selectedCell: { row: number; col: number; } | null; range: { start: { row: number; col: number; }; end: { row: number; col: number; }; } | null; selectedData: { row: T; column: string; value: unknown; }[]; } interface GridEventMap { pageChange: PageEvent; sortChange: SortEvent; filterChange: FilterEvent; groupChange: GroupEvent; columnResize: ColumnResizeEvent; columnReorder: ColumnReorderEvent; columnFreeze: ColumnFreezeEvent; columnVisibility: ColumnVisibilityEvent; columnSearchToggle: ColumnSearchToggleEvent; selectionChange: RowSelectionEvent; cellSelectionChange: CellSelectionEvent; rowClick: { row: T; index: number; event: MouseEvent; }; rowExpand: { row: T; index: number; expanded: boolean; }; cellEdit: CellEditEvent; cellEditCancel: CellEditCancelEvent; } type GridEventType = keyof GridEventMap; type GridDensity = 'small' | 'default' | 'large'; interface GridSettingsData { columns: { field: string; headerName: string; visible: boolean; }[]; density: GridDensity; defaultColumns: { field: string; headerName: string; visible: boolean; }[]; } interface GridSettingsResult { density: GridDensity; columns: { field: string; visible: boolean; order: number; }[]; } interface GroupEntry { field: string; sortDirection: 'asc' | 'desc'; } interface GroupDrawerData { groups: GroupEntry[]; availableColumns: { field: string; headerName: string; }[]; } interface GroupDrawerResult { groups: GroupEntry[]; } declare class GridStateManager { readonly sourceData: _angular_core.WritableSignal; readonly totalItems: _angular_core.WritableSignal; readonly mode: _angular_core.WritableSignal<"client" | "server">; readonly filterMode: _angular_core.WritableSignal; readonly loadingStrategy: _angular_core.WritableSignal; readonly columnDefs: _angular_core.WritableSignal[]>; readonly columnStates: _angular_core.WritableSignal; readonly activeSorts: _angular_core.WritableSignal; readonly groupColumns: _angular_core.WritableSignal; readonly expandedGroups: _angular_core.WritableSignal>; /** * Unified filter state: single source of truth for the multi-condition * builder. The tag-bar displays a derived view via `FilterEngine.toLabel()`. */ readonly filterModel: _angular_core.WritableSignal; /** `false` disables paging entirely — `paginatedData` returns the full * filtered set instead of slicing by `pageSize`. */ readonly paginationEnabled: _angular_core.WritableSignal; readonly pageIndex: _angular_core.WritableSignal; readonly pageSize: _angular_core.WritableSignal; readonly visibleRowCount: _angular_core.WritableSignal; readonly scrollLeft: _angular_core.WritableSignal; readonly scrollTop: _angular_core.WritableSignal; readonly scrollViewportWidth: _angular_core.WritableSignal; readonly scrollViewportHeight: _angular_core.WritableSignal; readonly scrollContentTotalWidth: _angular_core.WritableSignal; readonly horizontalVirtualScrollEnabled: _angular_core.WritableSignal; readonly visibleColumnRange: _angular_core.WritableSignal<{ start: number; end: number; }>; /** Range of display-row indices currently mounted in the DOM. */ readonly visibleRowRange: _angular_core.WritableSignal<{ start: number; end: number; }>; /** Pixel offset of the first rendered row from the top of the body content. */ readonly topSpacerHeight: _angular_core.WritableSignal; /** Pixel offset between the last rendered row and the bottom of the body content. */ readonly bottomSpacerHeight: _angular_core.WritableSignal; /** Total height of all display rows (data + group, includes expanded detail). */ readonly totalRowsHeight: _angular_core.WritableSignal; readonly isLoading: _angular_core.WritableSignal; readonly rowHeight: _angular_core.WritableSignal; readonly density: _angular_core.WritableSignal; readonly selectedRowIds: _angular_core.WritableSignal>; readonly excludedRowIds: _angular_core.WritableSignal>; readonly selectAllMode: _angular_core.WritableSignal<"none" | "page" | "all">; readonly focusedCell: _angular_core.WritableSignal; readonly selectedCell: _angular_core.WritableSignal; readonly cellRange: _angular_core.WritableSignal<{ start: CellCoord; end: CellCoord; } | null>; readonly isDragging: _angular_core.WritableSignal; readonly focusSource: _angular_core.WritableSignal<"click" | "keyboard" | null>; readonly isFilling: _angular_core.WritableSignal; readonly fillAnchor: _angular_core.WritableSignal; readonly fillTarget: _angular_core.WritableSignal; readonly cutSource: _angular_core.WritableSignal<{ start: CellCoord; end: CellCoord; } | null>; readonly expandedRowIds: _angular_core.WritableSignal>; readonly rowIdField: _angular_core.WritableSignal; readonly multiCellSelectionEnabled: _angular_core.WritableSignal; readonly activeSelectionMode: _angular_core.WritableSignal<"none" | "rows" | "cells">; readonly draggingColumn: _angular_core.WritableSignal; readonly dropIndicatorIndex: _angular_core.WritableSignal; readonly cellEditState: _angular_core.WritableSignal; /** `true` while the user is editing a formula inside the top formula bar * (outside any cell). Consumed by `FormulaEngine.isFormulaEditActive` * so headers show column-letter badges during bar-driven edits too. */ readonly formulaBarEditingActive: _angular_core.WritableSignal; readonly visibleColumns: _angular_core.Signal; readonly pinnedLeftColumns: _angular_core.Signal; readonly unpinnedColumns: _angular_core.Signal; readonly pinnedRightColumns: _angular_core.Signal; readonly pinnedLeftWidth: _angular_core.Signal; readonly pinnedRightWidth: _angular_core.Signal; /** * Cumulative `left` offset (px) for each pinned-left column, in render * order. Consumers add their own utility-cell prefix (checkbox/expand) and * pass the result to `position: sticky; left: px`. * Returns an array of length `pinnedLeftColumns().length`. */ readonly pinnedLeftCumulativeOffsets: _angular_core.Signal; /** * Cumulative `right` offset (px) for each pinned-right column, in render * order. The first column from the right (visually leftmost in the * pinned-right group) has the largest `right` offset. */ readonly pinnedRightCumulativeOffsets: _angular_core.Signal; readonly unpinnedWidth: _angular_core.Signal; /** * Unpinned columns actually rendered in data rows. When horizontal virtual scroll * is disabled, this is the full set; when enabled, it's the slice inside the * current visibleColumnRange. Header and filter row keep rendering the full set — * only row cells are virtualized. */ /** * Effective column range with edit-mode widening: keeps the column being edited * inside the rendered window so the editor never gets torn down mid-edit. */ readonly effectiveColumnRange: _angular_core.Signal<{ start: number; end: number; }>; readonly renderedUnpinnedColumns: _angular_core.Signal; readonly leadingColumnSpacer: _angular_core.Signal; readonly trailingColumnSpacer: _angular_core.Signal; readonly columnDefMap: _angular_core.Signal>>; /** `true` when at least one column declares `allowFormula: true`. */ readonly hasFormulaColumns: _angular_core.Signal; readonly gridTemplateColumns: _angular_core.Signal; readonly totalContentWidth: _angular_core.Signal; readonly totalPages: _angular_core.Signal; readonly hasMore: _angular_core.Signal; initColumns(defs: ColumnDef[]): void; updateColumnState(field: string, updates: Partial): void; private resolveWidth; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class RowSelectionEngine { private readonly state; private readonly engine; readonly selectedIds: _angular_core.Signal>; readonly excludedIds: _angular_core.Signal>; /** * Anchor row for shift-click range selection. We track the row object * (not its index) so the anchor stays valid across grouping, sorting and * filtering — where display indices shift without the underlying row * changing. */ readonly lastToggledRow: _angular_core.WritableSignal; readonly count: _angular_core.Signal; readonly pageSelectedCount: _angular_core.Signal; readonly isAllSelected: _angular_core.Signal; readonly isIndeterminate: _angular_core.Signal; /** * Extends the selection from the last-toggled row (the anchor) to `endRow`, * resolving positions by object identity against the currently paginated * data. This is robust to grouping / sorting / filtering because we don't * rely on numeric indices, and works across any visible page slice. */ selectRowRangeToRow(endRow: T): void; toggleRow(row: T): void; isRowSelected(row: T): boolean; selectAllPage(): void; selectAll(): void; deselectAll(): void; deselectPage(): void; toggleSelectAllPage(): void; getSelectionEvent(): RowSelectionEvent; getRowId(row: T): unknown; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } /** * Public types for the formula engine. These are the only symbols consumers * of the grid need to interact with. The parser / evaluator / DAG live in * `features/formula/` and expose the public surface through `FormulaEngine`. * * Shape overview: * - `CellAddress` — stable (rowId, field) tuple. * - `FormulaValue` — tagged union of numbers, strings, booleans, empty * and errors. Errors propagate through operators. * - `FormulaError` — Excel-compatible error codes + `#PARSE!`. * - `FormulaFunction*` — registration shape for built-in + custom funcs. * - `FormulaChange*` / `FormulaError*` — events emitted by the grid. */ /** Stable cell identifier, resistant to sort/filter/pagination. */ interface CellAddress { rowId: string | number; field: string; } /** Excel-compatible error codes, plus mozaic-specific `#PARSE!`. */ type FormulaError = '#DIV/0!' | '#VALUE!' | '#REF!' | '#NAME?' | '#NUM!' | '#N/A' | '#CYCLE!' | '#PARSE!'; /** * Tagged union for any value that can appear as a formula operand or result. * `empty` represents a cell with no source value (distinct from the empty * string) and coerces to 0 in arithmetic contexts, `""` in textual ones. */ type FormulaValue = { kind: 'number'; value: number; } | { kind: 'string'; value: string; } | { kind: 'boolean'; value: boolean; } | { kind: 'empty'; } | { kind: 'error'; error: FormulaError; }; /** * Context passed to every function implementation. Keeps evaluation * side-effect free: the engine owns the cell store and only exposes a * `resolveRef` primitive. Range expansion is handled by the engine before * the function is invoked, so implementations receive a flat value array. */ interface FormulaEvalContext { /** Current cell being evaluated (used for diagnostics only). */ readonly addr?: CellAddress; /** * Resolve a long-form reference. Returns `#REF!` when the target is * missing (column removed, row deleted). The engine is responsible for * cycle protection — functions must not worry about recursion. */ resolveRef(target: CellAddress): FormulaValue; /** Active locale, used by date/text helpers that are locale-aware. */ readonly locale: 'en' | 'fr'; } /** Arity constraint for a function registration. */ type FormulaArity = number | 'variadic' | readonly [min: number, max: number]; /** * Human-readable metadata shown in the autocomplete panel. When absent, the * suggestion listing falls back to the function name only. */ interface FormulaFunctionDocs { /** Canonical signature string, e.g. `SUM(number1, [number2, ...])`. */ readonly signature: string; /** One-line summary — displayed next to the signature in FR by default. */ readonly summary: string; } interface FormulaFunctionImpl { /** Number of arguments accepted. */ readonly arity: FormulaArity; /** * Whether the function accepts a range argument (e.g. `SUM(A1:B3)`). * When `true`, each range is flattened into the `args` array in * row-major order. When `false`, passing a range yields `#VALUE!`. * * Defaults to `false`. */ readonly acceptsRange?: boolean; /** Optional documentation — consumed by the editor's autocomplete panel. */ readonly docs?: FormulaFunctionDocs; /** Evaluate the function. Must be pure (no I/O, no mutation). */ evaluate(args: FormulaValue[], ctx: FormulaEvalContext): FormulaValue; } /** Lookup table of function name (uppercase) → implementation. */ type FormulaFunctionRegistry = Readonly>; /** * Source for storing formulas externally (instead of serialising the raw * formula into the row's field). Mirror of AG-Grid's `formulaDataSource`. */ interface FormulaDataSource { getFormula(addr: CellAddress): string | undefined; setFormula(addr: CellAddress, formula: string | undefined): void; /** Optional bulk hydration — useful for persistence layers. */ hydrate?(entries: Iterable<{ addr: CellAddress; formula: string; }>): void; } interface FormulaChangeEvent { addr: CellAddress; /** Canonical long-form formula (references keyed by rowId/field). */ formula: string; /** Last evaluated value after the change. */ evaluated: FormulaValue; } interface FormulaErrorEvent { addr: CellAddress; formula: string; error: FormulaError; } /** Factory helpers for callers that prefer not to build literals by hand. */ declare const FormulaValues: { readonly number: (value: number) => FormulaValue; readonly string: (value: string) => FormulaValue; readonly boolean: (value: boolean) => FormulaValue; readonly empty: () => FormulaValue; readonly error: (error: FormulaError) => FormulaValue; }; /** Narrow a value to a number, following Excel coercion rules. */ declare function toNumber(v: FormulaValue): number | FormulaError; /** Narrow a value to a string, following Excel coercion rules. */ declare function toStringValue(v: FormulaValue): string | FormulaError; /** Narrow a value to a boolean, following Excel coercion rules. */ declare function toBoolean(v: FormulaValue): boolean | FormulaError; /** Returns the first error found in the given values, or `null`. */ declare function firstError(values: readonly FormulaValue[]): FormulaError | null; /** * Maps structured refs (A1-backed, field-keyed) to / from long-form * `CellAddress` tuples, and converts formula *source strings* between the * A1 edit surface and the `REF(COLUMN("…"),ROW(N))` storage form. * * The mapper is the only component aware of the grid's current column * order — every other layer works exclusively with addresses, so reordering * columns or renaming a field's display label never breaks a stored formula. * * Surface round-trip: * * Editor types → a1ToLongForm(ctx) → REF(COLUMN(…),ROW(…)) (stored) * Stored REF long-form → longFormToA1(ctx) → A1 (displayed) * * The mapper is intentionally stateless and receives its dependencies * (fields list + row id list) through the method parameters. This keeps * it unit-testable without instantiating the whole grid. */ interface RefMapperContext { /** * Ordered list of column fields that can participate in formulas. Used * for A1 letter ↔ field conversion and for existence checks (an unknown * field yields `#REF!`). */ readonly fields: readonly string[]; /** * Row identifiers in display order. Index 0 = row `1` in the user-facing * surface syntax. For grids in server mode, callers typically provide the * *currently loaded* subset — unresolved references surface as `#REF!` * which is the expected behaviour for page-scoped formulas. */ readonly rowIds: readonly (string | number)[]; /** * Row id of the formula being resolved. The editor-side A1 helpers use * this to detect same-row refs (so the display can be relative by * default). */ readonly currentRowId?: string | number; } /** `(addr) → "A1"` using the current column order. */ declare function addressToA1(addr: CellAddress, ctx: RefMapperContext): string | undefined; /** * `FormulaEngine` — grid-scoped service that owns every formula cell, the * dependency DAG linking them, and the evaluator that turns stored * formulas into `FormulaValue`s. * * Responsibilities (Phase 1): * - Parse + resolve a raw formula when the user commits an edit. * - Update the dependency graph and detect cycles (`#CYCLE!`). * - Re-evaluate the mutated cell and every descendant in topological order. * - Expose a `values` signal the grid renders against. * - Provide an explicit `invalidate(addr)` so inline-edit can refresh * dependents after a *non-formula* source cell changes — avoiding a * blanket re-eval of the whole dataset. * * Out of scope (Phase ≥ 2): * - Editor component + autocomplete (uses `longFormToA1` under the hood). * - Clipboard / fill-handle rebasing of relative refs. * - History integration (undo/redo of formula mutations). */ declare class FormulaEngine { private readonly state; private readonly cells; private readonly dag; /** Last-evaluated values keyed by `rowId|field`. */ private readonly valuesSignal; /** Function registry — consumers can replace via `setFunctions`. */ private functions; /** Active locale for the parser/evaluator. */ private locale; /** Snapshot of all evaluated formula values. Consumers read by key. */ readonly values: Signal>; /** Whether any formula is currently tracked. */ readonly hasAnyFormula: Signal; /** * `true` when the user is currently editing a cell whose column has * `allowFormula: true`. The grid's header uses this to surface the * structured-ref column badges (`[price]`, `[qty]`, …) above each * header, matching what the user types in their formula. */ readonly isFormulaEditActive: Signal; /** Merge / replace the function registry (called once at grid init). */ setFunctions(functions: FormulaFunctionRegistry): void; /** Read-only view of the current function registry — used by the editor's * autocomplete panel to enumerate available names + their docs. */ getFunctions(): FormulaFunctionRegistry; setLocale(locale: 'en' | 'fr'): void; hasFormula(addr: CellAddress): boolean; /** Raw formula string, or `undefined` when none is stored. */ getFormula(addr: CellAddress): string | undefined; /** Last-evaluated value, or `undefined` when no formula is stored. */ valueAt(addr: CellAddress): FormulaValue | undefined; /** * Formula re-presented as A1 surface syntax for the current column / * row order. Returns `undefined` when the cell has no formula. Used by * the editor when opening a cell for edit. */ displayFormula(addr: CellAddress): string | undefined; /** * Registers or updates a formula at `addr`. Returns the freshly-computed * value. Invalid formulas are stored with their error as value so the * grid can render `#PARSE!` / `#REF!` etc. instead of silently dropping. */ set(addr: CellAddress, rawFormula: string): FormulaValue; /** Removes the formula at `addr`. Descendants are re-evaluated. */ remove(addr: CellAddress): void; /** * Notifies the engine that a non-formula cell changed. Only dependents * are re-evaluated — this is the hook used by `InlineEditEngine` after * committing a plain value edit. */ invalidate(addr: CellAddress): void; /** Wipes every formula / value. */ clear(): void; /** * Reconciles the engine against `sourceData()`: any cell whose column * declares `allowFormula: true` and whose value is a `=…` string is * registered (or updated). Cells previously registered but no longer * present (row removed, value changed to a literal) are dropped. * * Designed to be called from a grid-level effect tracking * `(formulas, sourceData, columnDefMap)` so that formulas baked into * the initial dataset are evaluated on first render — without it, the * engine would only learn about a formula after the user committed an * inline edit on it. * * The reconciliation is incremental: identical formula strings short- * circuit (no re-parse, no re-eval) so the call is cheap on stable data. */ syncFromSource(allowFormula: (field: string) => boolean): void; /** * Re-parses every stored formula so refs pick up the latest column * order / row list. Called by the grid shell when visibility or row * identity changes (reorder, filter flip, …). */ rebuild(): void; private refMapperContext; private storeError; /** * Evaluate the given seeds and every descendant in topological order. * Each node is first checked for cycle participation — any node inside * a cycle reports `#CYCLE!` without attempting evaluation (which would * recurse through the cached values and either spin or yield garbage). */ private revalidateFrom; private makeEvalContext; /** Resolve a reference: formula cell → cached value, else source data. */ private resolveRef; private readSourceValue; private commitValues; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } interface GridPlugin { name: string; init(state: GridStateManager): void; destroy(): void; } type GridToolbarSlot = 'start' | 'end'; declare class MozGridToolbarDef { readonly slot: _angular_core.InputSignal; readonly template: TemplateRef; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Discriminator for the empty-state context. * - `no-data` : the source dataset is empty (no rows ever loaded). * - `no-results` : the dataset is non-empty but the active filter / search * produced zero rows. * * A template registered without an explicit kind defaults to `no-data` and * is also used as the fallback when `no-results` has no dedicated template. */ type GridEmptyKind = 'no-data' | 'no-results'; /** * Marks a `` projected into `` as the renderer for * the empty state. Register one or two templates: * * ```html * * *

Aucune donnée pour le moment

* * * *

Aucun résultat pour vos filtres ({{ ctx.activeFilterCount }})

* * * * ``` * * The implicit context (`let-ctx`) exposes `{ activeFilterCount, clearFilters }`. */ declare class MozGridEmptyDef { readonly kind: _angular_core.InputSignal; readonly template: TemplateRef; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** Context object passed to a `mozGridEmptyDef` template. */ interface GridEmptyContext { /** Number of active filter conditions; `0` when called with `no-data`. */ activeFilterCount: number; /** Convenience callback to clear all filter conditions. */ clearFilters: () => void; } declare class MozGridComponent { protected readonly state: GridStateManager; private readonly gridEngine; private readonly sortEngine; private readonly inlineEditEngine; private readonly resizeEngine; protected readonly rowSelectionEngine: RowSelectionEngine; private readonly cellSelectionEngine; private readonly keyboardEngine; private readonly clipboardEngine; private readonly historyEngine; private readonly groupEngine; private readonly filterEngine; protected readonly formulaEngine: FormulaEngine; private readonly refHighlight; private readonly persistenceEngine; private readonly exportEngine; private readonly validationEngine; private readonly verticalVirtualScrollEngine; private readonly horizontalVirtualScrollEngine; private readonly paginationEngine; private readonly infiniteScrollEngine; private readonly gridContainer; private readonly ngZone; private readonly destroyRef; private readonly drawerService; private readonly columnDefs; private readonly toolbarDefs; private readonly emptyDefs; readonly data: _angular_core.InputSignal; readonly mode: _angular_core.InputSignal<"client" | "server">; readonly filterMode: _angular_core.InputSignal; readonly totalItems: _angular_core.InputSignal; readonly pagination: _angular_core.InputSignal; readonly pageSize: _angular_core.InputSignal; readonly pageSizeOptions: _angular_core.InputSignal; readonly rowHeight: _angular_core.InputSignal; readonly loading: _angular_core.InputSignal; readonly rowSelection: _angular_core.InputSignal; readonly expandable: _angular_core.InputSignal; readonly rowIdField: _angular_core.InputSignal; /** * Enables the spreadsheet-style formula engine. When `true`, any cell * committed with a leading `=` in a column declaring `allowFormula: true` * is routed to `FormulaEngine` and its evaluated value is rendered. */ readonly formulas: _angular_core.InputSignal; readonly detailTemplate: _angular_core.InputSignal | null>; readonly fullscreen: _angular_core.InputSignal; readonly reorderable: _angular_core.InputSignal; readonly stateKey: _angular_core.InputSignal; /** Title for the default "no data" empty state. */ readonly emptyDataTitle: _angular_core.InputSignal; /** Description for the default "no data" empty state. */ readonly emptyDataDescription: _angular_core.InputSignal; /** Title for the default "no results" empty state (active filters). */ readonly noResultsTitle: _angular_core.InputSignal; /** Description for the default "no results" empty state. */ readonly noResultsDescription: _angular_core.InputSignal; /** CTA label on the "no results" state. Empty disables the button. */ readonly noResultsActionLabel: _angular_core.InputSignal; readonly exportable: _angular_core.InputSignal; /** * `'client'` (default): the grid builds and downloads the CSV itself. * `'server'`: the grid emits `(exportRequest)` instead, leaving the consumer * to perform the export (e.g. a back-end download). */ readonly exportMode: _angular_core.InputSignal<"client" | "server">; readonly showToolbar: _angular_core.InputSignal; readonly multiCellSelection: _angular_core.InputSignal; readonly horizontalVirtualScroll: _angular_core.InputSignal; readonly loadingStrategy: _angular_core.InputSignal; readonly scrollThreshold: _angular_core.InputSignal; readonly plugins: _angular_core.InputSignal; readonly sortChange: _angular_core.OutputEmitterRef; readonly pageChange: _angular_core.OutputEmitterRef; readonly loadMore: _angular_core.OutputEmitterRef; readonly cellEdit: _angular_core.OutputEmitterRef>; readonly cellEditCancel: _angular_core.OutputEmitterRef; readonly selectionChange: _angular_core.OutputEmitterRef>; readonly cellSelectionChange: _angular_core.OutputEmitterRef>; readonly groupChange: _angular_core.OutputEmitterRef; readonly filterChange: _angular_core.OutputEmitterRef; readonly bulkEdit: _angular_core.OutputEmitterRef; readonly bulkCopy: _angular_core.OutputEmitterRef; readonly bulkPaste: _angular_core.OutputEmitterRef; readonly bulkDelete: _angular_core.OutputEmitterRef; readonly fillDown: _angular_core.OutputEmitterRef; readonly settingsChange: _angular_core.OutputEmitterRef; /** Emitted when the toolbar export is triggered while `exportMode === 'server'`. */ readonly exportRequest: _angular_core.OutputEmitterRef; protected readonly isFullscreen: _angular_core.WritableSignal; protected readonly groupPanelOpen: _angular_core.WritableSignal; /** * Mode controlling how the builder emits `filterChange`: * - `auto` : each mutation triggers an event (default in `client` mode). * - `manual` : only an explicit Apply emits (default in `server` mode). */ readonly filterApplyMode: _angular_core.InputSignal; protected readonly resolvedFilterApplyMode: _angular_core.Signal; /** Display descriptors for the "FILTERED BY" tag bar. */ protected readonly activeFilters: _angular_core.Signal; protected readonly activeFilterCount: _angular_core.Signal; /** * Kind of empty state to show, or `'none'` when rows are present: * - `'no-data'` : no rows have been loaded (and the source is empty). * - `'no-results'` : the source has rows but the active filters yield 0. * * Loading and infinite-scroll loading-more states are *not* treated as * empty (we let the loading indicator drive the UX instead). */ protected readonly emptyStateKind: _angular_core.Signal<"none" | GridEmptyKind>; /** Resolves the projected `` for the kind. */ protected readonly emptyTemplate: _angular_core.Signal | null>; /** Context object exposed to projected empty-state templates. */ protected readonly emptyContext: _angular_core.Signal; /** * Wrap the empty context for `ngTemplateOutlet` so consumers can use * either `let-ctx` (positional, via `$implicit`) or named bindings * (`let-clearFilters="clearFilters"`) without having to choose at * declaration time. */ protected readonly emptyTemplateContext: _angular_core.Signal<{ activeFilterCount: number; clearFilters: () => void; $implicit: GridEmptyContext; }>; /** CTA label for the default no-results state — hidden when no filters. */ protected readonly resolvedNoResultsActionLabel: _angular_core.Signal; protected readonly hasHiddenColumns: _angular_core.Signal; protected readonly hiddenColumnsList: _angular_core.Signal<{ field: string; label: string; }[]>; protected readonly toolbarStartDefs: _angular_core.Signal; protected readonly toolbarEndDefs: _angular_core.Signal; protected readonly selectionBannerVisible: _angular_core.Signal; protected readonly selectionTotalCount: _angular_core.Signal; protected readonly showPagination: _angular_core.Signal; protected readonly showInfiniteScrollLoader: _angular_core.Signal; /** Focused cell coord picked up by the formula bar — falls back to the * selected cell so the bar stays populated after focus is lost (e.g. * the user clicked outside to dismiss an overlay). */ private readonly formulaBarCoord; /** Snapshot coord captured at edit entry — kept as a signal so the * bar's address reads from it reactively and stays pinned to the * original cell even when the user clicks elsewhere to pick refs. */ private readonly formulaBarActiveCoord; /** A1 address (`A5`, `$A$5`) of the formula-bar target cell. While the * bar is editing the address stays pinned to the snapshot so ref * picking doesn't visually jump the label around. */ protected readonly formulaBarAddress: _angular_core.Signal; /** Formula source if the target cell holds one, otherwise the displayed * value as a string. Mirrors Excel's formula-bar behaviour. */ protected readonly formulaBarContent: _angular_core.Signal; /** `true` while the user is editing in the formula bar (mounts the * full-featured formula editor with ref highlights + autocomplete). */ protected readonly formulaBarEditing: _angular_core.WritableSignal; /** Live draft while the formula-bar input is focused. `null` means * "not editing" and the input mirrors `formulaBarContent()`. */ protected readonly formulaBarDraft: _angular_core.WritableSignal; /** Snapshot of the cell targeted when the formula bar gained focus. * Needed because blur fires *after* the click that moved the * selection elsewhere — without this we'd commit into the new cell. */ private formulaBarEditSnapshot; /** Value shown in the bar input — draft while editing, committed value otherwise. */ protected readonly formulaBarDisplay: _angular_core.Signal; /** Address of the cell the formula bar is editing (for `@row` * highlighting inside the embedded editor). Reads from the snapshot * so it stays stable while the user clicks other cells to pick refs. */ protected readonly formulaBarEditingAddr: _angular_core.Signal; /** `true` when the target cell sits in an editable column. */ protected readonly formulaBarEditable: _angular_core.Signal; private columnsInitialized; private stateRestored; private documentMouseUpHandler; constructor(); onSortClick(event: { field: string; isMultiSort: boolean; }): void; onMenuAction(event: { field: string; actionId: HeaderMenuActionId; }): void; onCellEdit(event: CellEditEvent): void; onSelectAllToggle(): void; onRowSelectionToggle(): void; private activateRowSelectionMode; onKeydown(event: KeyboardEvent): void; private handleEditModeKeydown; private commitFromEditMode; private onCutShortcut; private onUndo; private onRedo; private onFillDownShortcut; private onFillRightShortcut; private onStartEditShortcut; private resetInfiniteScrollIfActive; private refocusGrid; onMouseUp(): void; /** * Shifts a formula's relative refs by the given (row, col) delta when the * value is a formula string dropped on a new cell during a fill. Non-formula * values are returned as-is so downstream code can still see the raw value. */ private shiftFormulaForFill; /** * Maps a display row index (from displayRow.index) to the actual index in * sourceData(). When grouping or sorting is active the display index doesn't * match sourceData order, so we resolve via object identity. */ private displayIndexToSourceIndex; private applyFill; private applyVerticalFill; private applyHorizontalFill; onGroupToggle(groupKey: string): void; onRemoveGroup(field: string): void; onToggleGroupSort(field: string): void; onSelectAllRows(): void; onClearSelection(): void; /** Removes a single condition by id (tag "×" button). */ onRemoveFilter(id: string): void; /** Clears the whole filter model ("Remove all" button). */ onRemoveAllFilters(): void; onFiltersClick(): void; onRestoreColumn(field: string): void; toggleFullscreen(): void; onRestoreAllColumns(): void; getColumnLabel(field: string): string; onResizeStart(event: { field: string; event: MouseEvent; }): void; onExportCsv(): void; onGroupClick(): void; private applyGroupResult; onKeyboardShortcutsClick(): void; /** Clicking the readonly preview flips the bar into edit mode: we mount * the full formula editor on the next tick (it auto-focuses) and * snapshot the target cell so blur-ordering races can't mis-route * the commit to a different row. */ onFormulaBarInputFocus(): void; onFormulaBarEditorChange(value: string): void; onFormulaBarEditorCommit(): void; onFormulaBarEditorCancel(): void; /** Commit-on-outside-focus: when the user tabs or clicks truly away * from the bar (not onto a grid cell — cells aren't focusable so they * don't steal focus), persist the draft. */ onFormulaBarWrapperFocusout(event: FocusEvent): void; private exitFormulaBarEdit; private commitFormulaBar; /** * Convert a formula-bar A1 draft to REF long-form storage. Kept as a * member so it can re-use the grid's reactive context without threading * `fields` / `rowIds` through every caller. */ private a1FormulaToStorage; onFormulaReferenceClick(): void; private static readonly DENSITY_ROW_HEIGHT; onSettingsClick(): void; private applySettings; private freezeLeft; private freezeRight; private getRangeRowIds; private getRangeFields; private getRowSelectionIds; private getAllVisibleFields; /** * Resolves a list of internal `HistoryCellChange` records into the public * `BulkCellChange[]` shape exposed on bulk events. Looks up each row's * configured id so consumers can persist changes without a second pass. */ private toBulkCellChanges; private clearSelectionAndCloseBar; onBulkEdit(): void; onBulkCopy(): void; onBulkPaste(): Promise; onBulkExport(): void; onBulkDelete(): void; private extractRangeData; private extractRowSelectionData; private applyPasteToSelectedRows; private deleteSelectedRows; private coerceAndValidate; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "rowIdField": { "alias": "rowIdField"; "required": false; "isSignal": true; }; "formulas": { "alias": "formulas"; "required": false; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "emptyDataTitle": { "alias": "emptyDataTitle"; "required": false; "isSignal": true; }; "emptyDataDescription": { "alias": "emptyDataDescription"; "required": false; "isSignal": true; }; "noResultsTitle": { "alias": "noResultsTitle"; "required": false; "isSignal": true; }; "noResultsDescription": { "alias": "noResultsDescription"; "required": false; "isSignal": true; }; "noResultsActionLabel": { "alias": "noResultsActionLabel"; "required": false; "isSignal": true; }; "exportable": { "alias": "exportable"; "required": false; "isSignal": true; }; "exportMode": { "alias": "exportMode"; "required": false; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "multiCellSelection": { "alias": "multiCellSelection"; "required": false; "isSignal": true; }; "horizontalVirtualScroll": { "alias": "horizontalVirtualScroll"; "required": false; "isSignal": true; }; "loadingStrategy": { "alias": "loadingStrategy"; "required": false; "isSignal": true; }; "scrollThreshold": { "alias": "scrollThreshold"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; "filterApplyMode": { "alias": "filterApplyMode"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "pageChange": "pageChange"; "loadMore": "loadMore"; "cellEdit": "cellEdit"; "cellEditCancel": "cellEditCancel"; "selectionChange": "selectionChange"; "cellSelectionChange": "cellSelectionChange"; "groupChange": "groupChange"; "filterChange": "filterChange"; "bulkEdit": "bulkEdit"; "bulkCopy": "bulkCopy"; "bulkPaste": "bulkPaste"; "bulkDelete": "bulkDelete"; "fillDown": "fillDown"; "settingsChange": "settingsChange"; "exportRequest": "exportRequest"; }, ["columnDefs", "toolbarDefs", "emptyDefs"], ["[mozGridFilterTags]"], true, never>; } interface GroupRow { type: 'group'; field: string; value: unknown; displayValue: string; depth: number; count: number; expanded: boolean; groupKey: string; children: (GroupRow | T)[]; parent: GroupRow | null; } type DisplayRow = { type: 'data'; data: T; index: number; depth: number; } | { type: 'group'; group: GroupRow; } | { type: 'detail'; data: T; index: number; }; interface GridOptions { /** Data mode */ mode: 'client' | 'server'; /** Pagination */ pagination: boolean; pageSize: number; pageSizeOptions: number[]; /** Row height for virtual scroll (px) */ rowHeight: number; /** Enable row checkbox selection */ rowSelection: boolean; /** Selection mode */ selectionMode: 'single' | 'multiple'; /** Enable column grouping */ grouping: boolean; /** Enable fullscreen toggle */ fullscreen: boolean; /** Enable expandable rows */ expandableRows: boolean; /** Enable column resize */ columnResize: boolean; /** Enable column reorder */ columnReorder: boolean; /** Show or hide the toolbar. Defaults to true. */ showToolbar?: boolean; /** Enable multi-cell selection (click / drag range / keyboard navigation). Defaults to true. */ multiCellSelection?: boolean; /** Track by function for virtual scroll */ trackBy: (index: number, item: T) => unknown; } declare const DEFAULT_GRID_OPTIONS: GridOptions; declare class MozGridColumnDef { readonly field: _angular_core.InputSignal; readonly headerName: _angular_core.InputSignal; readonly width: _angular_core.InputSignal; readonly minWidth: _angular_core.InputSignal; readonly maxWidth: _angular_core.InputSignal; readonly flex: _angular_core.InputSignal; readonly sortable: _angular_core.InputSignal; readonly resizable: _angular_core.InputSignal; readonly reorderable: _angular_core.InputSignal; readonly groupable: _angular_core.InputSignal; readonly filterable: _angular_core.InputSignal; readonly filterType: _angular_core.InputSignal; readonly filterOperators: _angular_core.InputSignal; readonly defaultFilterOperator: _angular_core.InputSignal; readonly filterOptions: _angular_core.InputSignal<{ value: unknown; label: string; }[] | undefined>; readonly filterComponent: _angular_core.InputSignal | undefined>; readonly filterIsComplete: _angular_core.InputSignal<((value: FilterValue) => boolean) | undefined>; readonly filterPredicate: _angular_core.InputSignal<((row: unknown, value: FilterValue) => boolean) | undefined>; readonly editable: _angular_core.InputSignal; readonly visible: _angular_core.InputSignal; readonly hideable: _angular_core.InputSignal; readonly freezable: _angular_core.InputSignal; readonly headerMenuDisabled: _angular_core.InputSignal; /** * Mirrors `ColumnDef.allowFormula`. Required so the template binding * `[allowFormula]="true"` is forwarded into the generated column def — * without it, `FormulaEngine.syncFromSource` cannot detect this column * and any baked-in `=…` value is rendered as a raw string. */ readonly allowFormula: _angular_core.InputSignal; readonly pinned: _angular_core.InputSignal<"start" | "end" | null>; readonly cellEditor: _angular_core.InputSignal; readonly cellEditorOptions: _angular_core.InputSignal; readonly cellValidator: _angular_core.InputSignal<((value: unknown, row: unknown) => CellError | null) | undefined>; readonly cellTemplateInput: _angular_core.InputSignal | null>; readonly editTemplateInput: _angular_core.InputSignal | null>; readonly filterTemplateInput: _angular_core.InputSignal | null>; readonly cellTemplateContent: _angular_core.Signal | undefined>; readonly editTemplateContent: _angular_core.Signal | undefined>; readonly filterTemplateContent: _angular_core.Signal | undefined>; toColumnDef(): ColumnDef; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵdir: _angular_core.ɵɵDirectiveDeclaration, "moz-grid-column-def", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "headerName": { "alias": "headerName"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "flex": { "alias": "flex"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "groupable": { "alias": "groupable"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "filterType": { "alias": "filterType"; "required": false; "isSignal": true; }; "filterOperators": { "alias": "filterOperators"; "required": false; "isSignal": true; }; "defaultFilterOperator": { "alias": "defaultFilterOperator"; "required": false; "isSignal": true; }; "filterOptions": { "alias": "filterOptions"; "required": false; "isSignal": true; }; "filterComponent": { "alias": "filterComponent"; "required": false; "isSignal": true; }; "filterIsComplete": { "alias": "filterIsComplete"; "required": false; "isSignal": true; }; "filterPredicate": { "alias": "filterPredicate"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "hideable": { "alias": "hideable"; "required": false; "isSignal": true; }; "freezable": { "alias": "freezable"; "required": false; "isSignal": true; }; "headerMenuDisabled": { "alias": "headerMenuDisabled"; "required": false; "isSignal": true; }; "allowFormula": { "alias": "allowFormula"; "required": false; "isSignal": true; }; "pinned": { "alias": "pinned"; "required": false; "isSignal": true; }; "cellEditor": { "alias": "cellEditor"; "required": false; "isSignal": true; }; "cellEditorOptions": { "alias": "cellEditorOptions"; "required": false; "isSignal": true; }; "cellValidator": { "alias": "cellValidator"; "required": false; "isSignal": true; }; "cellTemplateInput": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; "editTemplateInput": { "alias": "editTemplate"; "required": false; "isSignal": true; }; "filterTemplateInput": { "alias": "filterTemplate"; "required": false; "isSignal": true; }; }, {}, ["cellTemplateContent", "editTemplateContent", "filterTemplateContent"], never, true, never>; } declare class GridEngine { private readonly state; private readonly sortEngine; private readonly filterEngine; private readonly groupEngine; /** * Pipeline step 1: sorted data. * In server mode, returns source data unchanged. */ readonly sortedData: _angular_core.Signal; /** * Pipeline step 2: filtered data. * In server mode, returns sorted data unchanged. */ readonly filteredData: _angular_core.Signal; /** * Pipeline step 3: paginated data. * In server mode, the data is already paginated by the server. * In infinite-scroll mode, all accumulated data is displayed (no slice). * Pagination applies before grouping so groups are per-page. */ readonly paginatedData: _angular_core.Signal; /** * Pipeline final: display rows (flat array for virtual scroll). * If grouped, produces group header + data rows. * If not grouped, wraps paginated data rows. */ readonly displayRows: _angular_core.Signal[]>; /** * Total items count for pagination. */ readonly computedTotalItems: _angular_core.Signal; /** * Resolves a display row index (as emitted via `DisplayRow.index`) to the * actual index in `sourceData()`. When sort/filter/group is active these do * not match, so we look up the display row's data object and search for it * in sourceData. Returns -1 when the display index is unknown. */ displayIndexToSourceIndex(displayIndex: number): number; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class SortEngine { private readonly state; toggleSort(field: string, isMultiSort: boolean): void; setSort(field: string, direction: SortDirection): void; clearSort(): void; sortData(data: T[]): T[]; private syncColumnSortState; private getValue; private defaultCompare; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class ColumnResizeEngine { private readonly state; private readonly ngZone; private resizing; private resizeField; private startX; private startWidth; private invertDelta; private readonly onMouseMove; private readonly onMouseUp; startResize(field: string, event: MouseEvent): void; getResizeEvent(field: string, previousWidth: number): ColumnResizeEvent; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class InlineEditEngine { private readonly state; private readonly history; private readonly gridEngine; private readonly formulaEngine; startEdit(rowIndex: number, field: string): void; /** * Excel-style "typing-to-edit": starts the editor with the cell value replaced * by the character the user just typed. For non-text editors (select / date / * checkbox / number) we coerce: the character is kept if it's compatible with * the editor, otherwise the editor opens on a cleared value. */ startEditWithChar(rowIndex: number, field: string, char: string): void; updateDraft(value: unknown): void; commitEdit(): CellEditEvent | null; cancelEdit(): CellEditCancelEvent | null; isEditing(rowIndex: number, colIndex: number): boolean; /** * Convert an A1-surface formula draft to REF long-form storage. Strings * that do not start with `=` are returned untouched — callers should * only invoke this on values they already know to be formulas. */ private a1DraftToStorage; resolveEditorType(field: string, value: unknown): CellEditorType; /** * Route a cell-edit commit through the formula engine when appropriate: * - `allowFormula` column + new value starts with `=` → register formula. * - `allowFormula` column + old value was a formula but new one isn't * → remove the stored formula (reverts to a plain literal). * - Any cell change → invalidate dependents so their cached value * refreshes (no-op when the engine has zero dependents on this cell). */ private updateFormulaEngine; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class CellSelectionEngine { private readonly state; focusCell(row: number, col: number, source?: 'click' | 'keyboard'): void; clearFocus(): void; isCellFocused(row: number, col: number): boolean; isCellInRange(row: number, col: number): boolean; selectRange(start: { row: number; col: number; }, end: { row: number; col: number; }): void; startRangeSelection(row: number, col: number): void; extendRange(row: number, col: number): void; endRangeSelection(): void; moveUp(): void; moveDown(): void; moveLeft(): void; moveRight(): void; moveToRowStart(): void; moveToRowEnd(): void; moveToGridStart(): void; moveToGridEnd(): void; /** * Excel-style Ctrl+Arrow: jump to the edge of the current data block. * If on an empty cell, jumps to the next non-empty cell. If on a filled * cell, jumps to the last filled cell before the next empty transition * (or to the grid edge if no empty cell is encountered). */ jumpToEdge(direction: 'up' | 'down' | 'left' | 'right'): void; movePage(direction: 'up' | 'down'): void; extendRangeBy(dRow: number, dCol: number): void; extendRangeToRowStart(): void; extendRangeToRowEnd(): void; extendRangeToGridStart(): void; extendRangeToGridEnd(): void; extendRangeJumpToEdge(direction: 'up' | 'down' | 'left' | 'right'): void; extendRangeByPage(direction: 'up' | 'down'): void; selectRow(row: number): void; selectColumn(col: number): void; selectAll(): void; private pageBounds; private pageRowStep; private directionVector; private inBounds; private isCellFilled; private findLastNonEmptyCol; private edgeFromCell; moveToNextEditableCell(): void; startFill(row: number, col: number): void; /** * Extends the fill range. The dominant axis (the one with the largest delta * from the anchor) wins: vertical if |dRow| >= |dCol|, otherwise horizontal. * The fill is 1D — it's always locked to a single row or a single column. */ extendFill(row: number, col: number): void; endFill(): { anchor: { row: number; col: number; }; target: { row: number; col: number; }; } | null; cancelFill(): void; isCellInFillRange(row: number, col: number): boolean; /** * During a horizontal fill, cells that sit inside the drag bounding box but * belong to a non-editable column cannot receive the filled value. We expose * them here so the view can paint a red dashed outline — a visual cue that * the fill is skipping that column. */ isCellInFillRejectRange(row: number, col: number): boolean; private isColEditable; /** * Returns the effective editor type for a column index. * Falls back to 'text' when no explicit cellEditor is defined. */ private getColEditorType; /** * Checks whether the source column's editor type is compatible with the * target column's editor type for a horizontal fill operation. * text↔text, number↔number, select↔select, etc. — only same-type is allowed. */ private isColTypeCompatible; private moveBy; getNormalizedRange(): CellRange | null; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } /** * Actions that require grid-level orchestration (event emission, clipboard * system access, async, UI refocus). The keyboard engine can run pure * navigation locally, but bounces these back to the host component. */ interface KeyboardActions { copy: () => void; paste: () => void; cut: () => void; deleteRange: () => void; undo: () => void; redo: () => void; fillDown: () => void; fillRight: () => void; startEdit: (row: number, col: number, initialChar?: string) => void; } declare class KeyboardEngine { private readonly cellSelection; private readonly inlineEdit; private readonly state; private actions; registerActions(actions: KeyboardActions): void; handleKeydown(event: KeyboardEvent): void; /** Returns true when the event was handled (so the caller should preventDefault). */ private dispatch; private handleArrow; /** * A key press is "printable" when it represents exactly one character that * the user intends as input — excluding named keys like F1, Home, Arrow*, * etc. Also excludes IME composition events (event.isComposing). */ private isPrintableKey; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class GroupEngine { private readonly state; addGroup(field: string): void; removeGroup(field: string): void; applyGroups(groups: GroupEntry[]): void; clearGroups(): void; toggleGroupExpand(groupKey: string): void; isGroupExpanded(groupKey: string): boolean; groupData(data: T[]): DisplayRow[]; private buildGroups; private flattenGroups; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class FilterEngine { private readonly state; /** Latest mutation, used by the grid shell to emit `filterChange` once. */ private readonly lastChange; readonly conditions: Signal; readonly hasActiveFilters: Signal; readonly lastEvent: Signal; /** Replaces the whole model in one go. Used by the drawer's Apply button. */ setModel(model: FilterModel, reason?: FilterChangeReason): void; addCondition(condition: FilterCondition): void; updateCondition(id: string, patch: Partial): void; removeCondition(id: string): void; reorderConditions(fromIndex: number, toIndex: number): void; clearAll(): void; /** Convenience: drop all conditions that target a given field. */ removeByField(field: string): void; /** * Drops conditions whose value is not yet complete. Called when a filter * builder is dismissed: a row the user added but never filled in must not * linger in the model as a phantom active filter. */ dropIncompleteConditions(): void; /** * Evaluates the current model against the provided data. * In `server` filterMode the grid delegates filtering to the consumer — returns input as-is. */ filterData(data: T[]): T[]; private isComplete; private matchRow; /** Returns a human-readable label for a condition ("Status equals En stock"). */ toLabel(condition: FilterCondition): string; /** Returns the filter data type inferred for a column. */ getFilterType(field: string): FilterDataType; /** * Builds the column descriptors consumed by the filter builder UI. * * All `filterable` columns are included, even those that ship a custom * `filterTemplate`. The custom template drives the inline header filter * row (quick per-column UI), while the builder — rendered in the toolbar * drawer and in the column-menu overlay — always uses the generic editors. * The two mechanisms are complementary and can coexist on the same column. */ describeFilterableColumns(): FilterColumnDescriptor[]; describeColumn(def: ColumnDef): FilterColumnDescriptor; /** Factory for new conditions created by the UI. */ makeCondition(field: string, isFirst: boolean, overrides?: Partial): FilterCondition; private notify; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class ColumnReorderEngine { private readonly state; reorder(previousIndex: number, newIndex: number): void; /** * Reorder using indices relative to unpinned columns only. * Translates to global columnStates indices before applying. */ reorderUnpinned(unpinnedPrevIndex: number, unpinnedNewIndex: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class ExpandableRowEngine { private readonly state; readonly hasExpandedRows: _angular_core.Signal; toggleRow(rowId: unknown): void; expandRow(rowId: unknown): void; collapseRow(rowId: unknown): void; collapseAll(): void; isRowExpanded(rowId: unknown): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } interface PersistedGridState { columns: Array<{ field: string; currentWidth: number; order: number; visible: boolean; pinned: 'start' | 'end' | null; }>; sorts: SortDef[]; /** Serialised filter conditions. `id` is regenerated on restore. */ filters?: Array>; } declare class StatePersistenceEngine { private readonly state; save(storageKey: string): void; restore(storageKey: string): boolean; clear(storageKey: string): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } interface ExportOptions { filename?: string; separator?: string; includeHeaders?: boolean; columns?: string[]; } declare class ExportEngine { private readonly state; exportCsv(data: T[], options?: ExportOptions): void; exportJson(data: T[], options?: { filename?: string; columns?: string[]; }): void; private escapeCsvValue; private downloadFile; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } interface TreeNodeConfig { childrenField: string; hasChildrenField?: string; expandedByDefault?: boolean; } interface TreeDisplayRow { type: 'data'; data: T; index: number; depth: number; hasChildren: boolean; expanded: boolean; nodeKey: string; } declare class TreeEngine { private readonly state; flatten(data: T[], config: TreeNodeConfig, expandedNodes: Set, idField: string): TreeDisplayRow[]; toggleNode(nodeKey: string): void; expandAll(data: T[], config: TreeNodeConfig, idField: string): void; collapseAll(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class CellValidationEngine { private readonly state; /** Map<"rowIndex:field", CellError> */ readonly cellErrors: _angular_core.WritableSignal>; /** Number of cells currently in error */ readonly errorCount: _angular_core.Signal; /** Revalidate all cells for the given data slice */ validateAll(data: T[]): void; /** Revalidate a single cell */ validateCell(rowIndex: number, field: string, value: unknown, row: T): void; /** Get the error for a specific cell, or null */ getCellError(rowIndex: number, field: string): CellError | null; /** Check if a specific cell has an error */ hasCellError(rowIndex: number, field: string): boolean; /** Clear all errors */ clearAll(): void; private removeCellError; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class HorizontalVirtualScrollEngine { private readonly state; /** Cumulative left offsets of unpinned columns. Length = unpinnedColumns.length + 1. */ private offsets; constructor(); /** Called by grid.ts when the body viewport scrolls or resizes. */ onScroll(scrollLeft: number, viewportWidth: number): void; rebuildOffsets(): void; private recompute; /** Binary search: returns the largest index i such that offsets[i] <= x. */ private findIndexAt; private fullRange; private setRange; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class PaginationEngine { private readonly state; readonly totalPages: _angular_core.Signal; readonly currentPage: _angular_core.Signal; readonly startItem: _angular_core.Signal; readonly endItem: _angular_core.Signal; readonly isFirstPage: _angular_core.Signal; readonly isLastPage: _angular_core.Signal; private readonly computedTotal; goToPage(pageIndex: number): void; nextPage(): void; previousPage(): void; setPageSize(size: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class InfiniteScrollEngine { private readonly state; private readonly destroyRef; private readonly ngZone; private scrollListener; private scrollElement; private loadMoreCallback; readonly scrollThreshold: _angular_core.WritableSignal; readonly hasMore: _angular_core.Signal; readonly isActive: _angular_core.Signal; attach(scrollElement: HTMLElement, onLoadMore: (event: LoadMoreEvent) => void): void; detach(): void; private checkScrollPosition; /** * Reset scroll state — called when sort/filter changes require * reloading from offset 0. */ reset(onLoadMore: (event: LoadMoreEvent) => void): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } /** * Default registry of formula functions (Phase 1 scope). * * Implementations are intentionally compact and reuse the coercion helpers * in `models/formula.model.ts`. Each entry is pure, side-effect free and * returns a `FormulaValue` — errors are data, never exceptions. * * Naming: keys are uppercase; the parser uppercases every identifier before * dispatch so consumers can write `sum(a, b)` or `SUM(a,b)` interchangeably. */ /** * Default function registry. Consumers can spread this into their own * registry to extend it: * * ``` * const registry = { ...DEFAULT_FORMULA_FUNCTIONS, TVA: myTvaFn }; * ``` */ declare const DEFAULT_FORMULA_FUNCTIONS: FormulaFunctionRegistry; declare function trackDisplayRow(_index: number, row: DisplayRow): string; declare function trackByField(_index: number, col: { field: string; }): string; declare class MozGridHeaderComponent { protected readonly state: GridStateManager; protected readonly rowSelection: RowSelectionEngine; private readonly dragEngine; protected readonly trackByField: typeof trackByField; readonly headerCenter: _angular_core.Signal | undefined>; readonly showCheckbox: _angular_core.InputSignal; readonly showExpand: _angular_core.InputSignal; readonly reorderable: _angular_core.InputSignal; readonly sortClick: _angular_core.OutputEmitterRef<{ field: string; isMultiSort: boolean; }>; readonly menuAction: _angular_core.OutputEmitterRef<{ field: string; actionId: HeaderMenuActionId; }>; readonly resizeStart: _angular_core.OutputEmitterRef<{ field: string; event: MouseEvent; }>; readonly selectAllToggle: _angular_core.OutputEmitterRef; readonly columnReorder: _angular_core.OutputEmitterRef<{ previousIndex: number; currentIndex: number; }>; constructor(); protected readonly utilityLeftWidth: _angular_core.Signal; protected readonly rowMinWidth: _angular_core.Signal; protected readonly hasFilterRow: _angular_core.Signal; getFilterTemplate(field: string): TemplateRef | null; onSelectAllClick(event: Event): void; onDragStart(event: MouseEvent, unpinnedIndex: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Programmatically opens a CDK overlay anchored on the host element that * renders the filter builder. Unlike the action-listbox directive, the * overlay does not toggle on click — the host is simply the anchor. Open * the overlay by injecting this directive via a template ref (`#filter`) * and calling `filter.open(options)`. */ declare class MozGridFilterOverlayDirective implements OnDestroy { private readonly overlay; private readonly host; private readonly injector; private readonly engine; private overlayRef; private componentRef; /** Opens the overlay anchored on the host. No-op if already open. */ open(options: { columns: FilterColumnDescriptor[]; model: FilterModel; /** Optional pre-selected column to seed a new condition. */ seedField?: string; onChange: (model: FilterModel) => void; }): void; close(): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class MozGridHeaderCellComponent { private readonly state; private readonly filterEngine; /** Optional — only present when the grid provides `FormulaEngine`. */ private readonly formulaEngine; readonly columnState: _angular_core.InputSignal; readonly def: _angular_core.InputSignal>; readonly isLast: _angular_core.InputSignal; readonly pinnedEnd: _angular_core.InputSignal; readonly reorderable: _angular_core.InputSignal; /** When set, applies `position: sticky` with the given side. */ readonly pinnedSticky: _angular_core.InputSignal<"left" | "right" | null>; /** Pixel offset for `left` (left-pinned) or `right` (right-pinned). */ readonly pinnedOffset: _angular_core.InputSignal; /** Visual edge of the pinned section — drives the separation shadow. */ readonly pinnedEdge: _angular_core.InputSignal<"left" | "right" | null>; protected readonly filterOverlay: _angular_core.Signal; /** True when at least one active condition targets this column. */ readonly hasActiveFilter: _angular_core.Signal; /** Tooltip for the gear / filter button (count + short summary). */ readonly filterTooltip: _angular_core.Signal; readonly resolvedMinWidth: _angular_core.Signal; readonly isDragging: _angular_core.Signal; readonly sortClick: _angular_core.OutputEmitterRef<{ field: string; isMultiSort: boolean; }>; readonly menuAction: _angular_core.OutputEmitterRef<{ field: string; actionId: HeaderMenuActionId; }>; readonly resizeStart: _angular_core.OutputEmitterRef; readonly label: _angular_core.Signal; /** * Spreadsheet-style column letter (`A`, `B`, …, `AA`, `AB`, …) matching * this column's position in the visible column order. Shown above each * header while a formula is being edited so the user sees exactly what * letter to type to reference a cell in this column. */ readonly columnLetter: _angular_core.Signal; /** * `true` when the user is editing a formula-capable cell. The header * uses this to show the column-letter badge — a visual cue matching the * A1 references the user types in the formula bar. */ readonly showColumnLetter: _angular_core.Signal; readonly menuItems: _angular_core.Signal; onHeaderClick(event: MouseEvent): void; onMenuItemClick(item: MozActionListItem): void; private openFilterOverlay; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid-header-cell", never, { "columnState": { "alias": "columnState"; "required": true; "isSignal": true; }; "def": { "alias": "def"; "required": true; "isSignal": true; }; "isLast": { "alias": "isLast"; "required": false; "isSignal": true; }; "pinnedEnd": { "alias": "pinnedEnd"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "pinnedSticky": { "alias": "pinnedSticky"; "required": false; "isSignal": true; }; "pinnedOffset": { "alias": "pinnedOffset"; "required": false; "isSignal": true; }; "pinnedEdge": { "alias": "pinnedEdge"; "required": false; "isSignal": true; }; }, { "sortClick": "sortClick"; "menuAction": "menuAction"; "resizeStart": "resizeStart"; }, never, never, true, never>; } declare class MozGridBodyComponent { protected readonly state: GridStateManager; protected readonly engine: GridEngine; private readonly expandableEngine; private readonly verticalEngine; readonly bodyContainer: _angular_core.Signal | undefined>; private readonly rowEls; readonly showCheckbox: _angular_core.InputSignal; readonly showExpand: _angular_core.InputSignal; readonly detailTemplate: _angular_core.InputSignal | null>; readonly cellEdit: _angular_core.OutputEmitterRef>; readonly cellEditCancel: _angular_core.OutputEmitterRef; readonly rowSelectionToggle: _angular_core.OutputEmitterRef; readonly groupToggle: _angular_core.OutputEmitterRef; /** Width consumed by sticky utility cells before the first pinned-left * column — must match `MozGridRowComponent.utilityLeftWidth()` so the * detail/group rows align with the data row layout. */ protected readonly utilityLeftWidth: _angular_core.Signal; /** Number of skeleton rows shown while loading — match page size, max 20. */ protected readonly skeletonRows: _angular_core.Signal; /** Concrete display-row indices to render this frame. */ protected readonly visibleIndices: _angular_core.Signal; protected isRowExpanded(data: unknown): boolean; private resizeObserver; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozGridRowComponent { protected readonly state: GridStateManager; private readonly inlineEdit; private readonly rowSelection; private readonly expandableEngine; private readonly elRef; protected readonly trackByField: typeof trackByField; readonly row: _angular_core.InputSignal; readonly rowIndex: _angular_core.InputSignal; readonly showCheckbox: _angular_core.InputSignal; readonly showExpand: _angular_core.InputSignal; readonly cellEdit: _angular_core.OutputEmitterRef<{ row: T; rowIndex: number; field: string; oldValue: unknown; newValue: unknown; }>; readonly cellEditCancel: _angular_core.OutputEmitterRef<{ rowIndex: number; field: string; originalValue: unknown; }>; readonly rowSelectionToggle: _angular_core.OutputEmitterRef; readonly isSelected: _angular_core.Signal; readonly isExpanded: _angular_core.Signal; /** Width consumed by sticky utility cells before the first pinned-left * column (expand button + checkbox). */ protected readonly utilityLeftWidth: _angular_core.Signal; onExpandClick(event: Event): void; onCheckboxClick(event: MouseEvent): void; onCommitEdit(): void; onCancelEdit(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid-row", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "cellEditCancel": "cellEditCancel"; "rowSelectionToggle": "rowSelectionToggle"; }, never, never, true, never>; } declare class MozGridCellComponent { private readonly state; private readonly inlineEdit; private readonly cellSelectionEngine; private readonly validationEngine; private readonly clipboard; private readonly gridEngine; /** Optional: present only when the grid provides `FormulaEngine`. */ private readonly formulaEngine; private readonly refHighlight; private readonly elRef; constructor(); private focusEditor; readonly row: _angular_core.InputSignal; readonly rowIndex: _angular_core.InputSignal; readonly colIndex: _angular_core.InputSignal; readonly colState: _angular_core.InputSignal; readonly def: _angular_core.InputSignal>; readonly isLast: _angular_core.InputSignal; readonly pinnedEnd: _angular_core.InputSignal; /** When set, applies `position: sticky` with the given side; the offset is * read from `pinnedOffset()`. */ readonly pinnedSticky: _angular_core.InputSignal<"left" | "right" | null>; /** Pixel offset applied to `left` (when `pinnedSticky === 'left'`) or * `right` (when `'right'`). */ readonly pinnedOffset: _angular_core.InputSignal; /** Marks the cell at the visual edge of its pinned section so it can paint * the shadow that separates frozen columns from the scrollable area. */ readonly pinnedEdge: _angular_core.InputSignal<"left" | "right" | null>; readonly resolvedMinWidth: _angular_core.Signal; readonly commitEdit: _angular_core.OutputEmitterRef; readonly cancelEdit: _angular_core.OutputEmitterRef; onFormulaCancel(): void; readonly cellTemplate: _angular_core.Signal<_angular_core.TemplateRef | null>; readonly editTemplate: _angular_core.Signal<_angular_core.TemplateRef | null>; readonly updateDraftFn: (value: unknown) => void; readonly commitEditFn: () => void; /** * Stable cell address for the formula engine. `null` when the column * isn't formula-enabled or the row lacks a stable id (e.g. headers). */ private readonly formulaAddr; /** * Last-evaluated `FormulaValue` for this cell, or `null` when the cell * holds no formula. Reactivity is driven by `formulaEngine.values`. */ readonly formulaValue: _angular_core.Signal; readonly value: _angular_core.Signal; readonly displayValue: _angular_core.Signal; /** `true` when the current cell value is a formula error (e.g. `#DIV/0!`). */ readonly hasFormulaError: _angular_core.Signal; /** * Currently editing and the draft is a formula (starts with `=`). * Drives the switch to `MozGridFormulaEditorComponent` instead of the * default text input. */ readonly isFormulaEditing: _angular_core.Signal; /** * Palette CSS var for the coloured border shown when this cell is * currently referenced by the formula being edited elsewhere. `null` * when no editor is active or this cell is not referenced. */ readonly refHighlightColor: _angular_core.Signal; readonly editState: _angular_core.Signal<_mozaic_ds_angular.CellEditState>; readonly isEditing: _angular_core.Signal; readonly editorType: _angular_core.Signal; readonly isFocused: _angular_core.Signal; readonly isInRange: _angular_core.Signal; readonly isInFillRange: _angular_core.Signal; readonly isInFillRejectRange: _angular_core.Signal; readonly cutEdges: _angular_core.Signal<{ top: boolean; right: boolean; bottom: boolean; left: boolean; any: boolean; }>; readonly cellError: _angular_core.Signal<_mozaic_ds_angular.CellError | null>; onCellClick(event: MouseEvent): void; onMouseDown(event: MouseEvent): void; onMouseEnter(): void; onDoubleClick(): void; onEditorInput(event: Event): void; onSelectChange(event: Event): void; onCheckboxChange(event: Event): void; onDateChange(value: string | null): void; onFillHandleMouseDown(event: MouseEvent): void; onEditorBlur(event: FocusEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid-cell", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "colIndex": { "alias": "colIndex"; "required": true; "isSignal": true; }; "colState": { "alias": "colState"; "required": true; "isSignal": true; }; "def": { "alias": "def"; "required": true; "isSignal": true; }; "isLast": { "alias": "isLast"; "required": false; "isSignal": true; }; "pinnedEnd": { "alias": "pinnedEnd"; "required": false; "isSignal": true; }; "pinnedSticky": { "alias": "pinnedSticky"; "required": false; "isSignal": true; }; "pinnedOffset": { "alias": "pinnedOffset"; "required": false; "isSignal": true; }; "pinnedEdge": { "alias": "pinnedEdge"; "required": false; "isSignal": true; }; }, { "commitEdit": "commitEdit"; "cancelEdit": "cancelEdit"; }, never, never, true, never>; } declare class MozGridFooterComponent { protected readonly state: GridStateManager; protected readonly engine: GridEngine; readonly pageSizeOptions: _angular_core.InputSignal; readonly pageChange: _angular_core.OutputEmitterRef; readonly currentPageSizeStr: _angular_core.Signal; readonly pageSizeSelectOptions: _angular_core.Signal<{ text: string; value: string; }[]>; readonly paginationOptions: _angular_core.Signal<{ text: string; value: number; }[]>; readonly rangeLabel: _angular_core.Signal; onPageChange(newPageIndex: number): void; onPageSizeChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozGridGroupRowComponent { protected readonly state: GridStateManager; readonly groupRow: _angular_core.InputSignal>; readonly toggleExpand: _angular_core.OutputEmitterRef; readonly fieldLabel: _angular_core.Signal; readonly groupValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid-group-row", never, { "groupRow": { "alias": "groupRow"; "required": true; "isSignal": true; }; }, { "toggleExpand": "toggleExpand"; }, never, never, true, never>; } declare class MozGridDetailRowComponent { readonly data: _angular_core.InputSignal; readonly rowIndex: _angular_core.InputSignal; readonly detailTemplate: _angular_core.InputSignal | null>; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-grid-detail-row", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>; } declare class MozGridColumnVisibilityPanelComponent { private readonly state; readonly restoreColumn: _angular_core.OutputEmitterRef; readonly restoreAll: _angular_core.OutputEmitterRef; readonly hiddenColumns: _angular_core.Signal<{ field: string; label: string; }[]>; onRestore(field: string): void; onRestoreAll(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozGridHeaderMenuComponent { private readonly state; readonly field: _angular_core.InputSignal; readonly isOpen: _angular_core.InputSignal; readonly actionClick: _angular_core.OutputEmitterRef<{ field: string; actionId: HeaderMenuActionId; }>; readonly close: _angular_core.OutputEmitterRef; readonly menuItems: _angular_core.Signal; onItemClick(item: MozActionListItem): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type SettingsScreen = 'main' | 'density' | 'columns'; interface DraftColumn { field: string; headerName: string; visible: boolean; } declare class GridSettingsDrawerComponent { private readonly drawerRef; private readonly data; readonly screen: _angular_core.WritableSignal; readonly draftDensity: _angular_core.WritableSignal; readonly draftColumns: _angular_core.WritableSignal; readonly searchQuery: _angular_core.WritableSignal; readonly densityOptions: { text: string; value: string; }[]; readonly densityLabel: _angular_core.Signal; readonly columnsLabel: _angular_core.Signal; readonly filteredColumns: _angular_core.Signal; private readonly defaultColumns; constructor(); goTo(screen: SettingsScreen): void; onColumnToggle(field: string, checked: boolean): void; onColumnDrop(event: CdkDragDrop): void; onSearchInput(event: Event): void; hideAll(): void; showAll(): void; apply(): void; reset(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface DraftGroupItem { field: string; headerName: string; sortDirection: 'asc' | 'desc'; } declare class GridGroupDrawerComponent { private readonly drawerRef; private readonly data; readonly draftGrouped: _angular_core.WritableSignal; private readonly allAvailable; readonly available: _angular_core.Signal<{ field: string; headerName: string; }[]>; onDrop(event: CdkDragDrop): void; onSortDirectionChange(index: number, event: Event): void; addGroup(field: string): void; removeGroup(field: string): void; apply(): void; reset(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MozGridLoadingIndicatorComponent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Structural host for custom filter components inside the filter builder. * * Usage in template: * */ declare class MozCustomFilterHostDirective implements OnChanges, OnDestroy { readonly componentType: _angular_core.InputSignal>; readonly condition: _angular_core.InputSignal; readonly conditionChange: _angular_core.OutputEmitterRef; private readonly vcr; private ref; private sub; ngOnChanges(changes: SimpleChanges): void; ngOnDestroy(): void; private teardown; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * McCombobox — Data models & type guards * * @packageDocumentation */ interface MozComboboxOption { /** Unique value used for selection comparison */ value: T; /** Display label */ label: string; /** Optional secondary text rendered below the label */ content?: string; /** Whether the option is individually disabled */ disabled?: boolean; /** Optional icon identifier (rendered in the prepend slot) */ icon?: string; } interface MozComboboxSection { /** Section heading text */ title: string; /** Options belonging to this section */ options: MozComboboxOption[]; /** When `true` in `multiple` mode, clicking the header toggles all children */ checkable?: boolean; /** * When `true`, the section header's "toggle all" action is disabled, but * children remain individually interactable. The header checkbox still * reflects the selection state (checked / indeterminate) of its children. */ disabled?: boolean; } type MozComboboxItem = MozComboboxOption | MozComboboxSection; type MozComboboxSize = 's' | 'm'; /** Type-guard: returns `true` when the item is a section header */ declare function isSection(item: MozComboboxItem): item is MozComboboxSection; interface FlatOption { type: 'option'; value: T; label: string; content?: string; disabled?: boolean; icon?: string; /** Parent section title (if any) */ sectionTitle?: string; } interface FlatSection { type: 'section'; title: string; checkable?: boolean; disabled?: boolean; } type FlatItem = FlatOption | FlatSection; declare function isFlatSection(item: FlatItem): item is FlatSection; declare function isFlatOption(item: FlatItem): item is FlatOption; declare class MozComboboxComponent implements ControlValueAccessor { private readonly _doc; /** Items to display (flat options or sections) */ readonly items: _angular_core.InputSignal[]>; /** Currently selected value(s) — two-way binding with model() */ readonly value: _angular_core.ModelSignal; /** Placeholder text shown when nothing is selected */ readonly placeholder: _angular_core.InputSignal; /** Enable multi-selection */ readonly multiple: _angular_core.InputSignal; /** Show counter instead of tags in multi mode */ readonly compact: _angular_core.InputSignal; /** Component size variant */ readonly size: _angular_core.InputSignal; /** Disable the entire component */ readonly disabled: _angular_core.InputSignal; /** Readonly mode — no interaction allowed */ readonly readonly: _angular_core.InputSignal; /** Show invalid/error styling */ readonly invalid: _angular_core.InputSignal; /** Show a clear button when a value is selected */ readonly clearable: _angular_core.InputSignal; /** Show a search/filter input inside the dropdown */ readonly searchable: _angular_core.InputSignal; /** * When true, the search query is split on spaces/commas and each term is * matched independently (e.g. "red shoe" matches labels containing either * "red" or "shoe"). When false, the query is matched as a single substring * so users can search for multi-word labels like "Item 1". */ readonly multiSearch: _angular_core.InputSignal; /** Show "Select all / Clear" action buttons (multiple only) */ readonly showActions: _angular_core.InputSignal; /** Whether the component is in a loading state (e.g. async data) */ readonly loading: _angular_core.InputSignal; /** Custom comparator for option values */ readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>; /** * Predicate used by `selectAll()` to decide whether a non-disabled option * should be included. Receives each candidate option and must return `true` * to keep it. Defaults to including every selectable option. Use this to * apply custom business rules (quotas, role-based filtering, etc.) when the * user triggers the "Select all" action. */ readonly canSelectAll: _angular_core.InputSignal<(option: MozComboboxOption) => boolean>; /** Accessible label */ readonly ariaLabel: _angular_core.InputSignal; /** Reference to an external label element */ readonly ariaLabelledBy: _angular_core.InputSignal; /** Placeholder shown inside the search input */ readonly searchPlaceholder: _angular_core.InputSignal; /** Text shown when no items match the search query */ readonly noResultsText: _angular_core.InputSignal; /** Label for the "Select all" action button */ readonly selectAllText: _angular_core.InputSignal; /** Label for the "Clear" action button */ readonly clearText: _angular_core.InputSignal; /** Suffix for the compact counter (e.g. "3 selected") */ readonly selectedSuffix: _angular_core.InputSignal; /** Accessible label for the clear button */ readonly clearAriaLabel: _angular_core.InputSignal; /** Text shown inside the dropdown while loading */ readonly loadingText: _angular_core.InputSignal; /** Whether to show the "No results found" message when no items match */ readonly showNoResultText: _angular_core.InputSignal; readonly opened: _angular_core.OutputEmitterRef; readonly closed: _angular_core.OutputEmitterRef; readonly searched: _angular_core.OutputEmitterRef; private readonly triggerEl; private readonly viewportEl; /** Unique instance id */ readonly uniqId: number; readonly comboboxId: string; readonly listboxId: string; /** Whether the dropdown panel is open */ readonly isOpen: _angular_core.WritableSignal; /** Keyboard-focused item index within filteredItems() */ readonly focusedIndex: _angular_core.WritableSignal; /** Current search/filter query */ readonly searchQuery: _angular_core.WritableSignal; /** Disabled state from ControlValueAccessor */ private readonly _disabledFromForm; /** Cache of value → label for all options ever seen (survives items changes) */ private readonly _labelCache; /** CVA callbacks */ private _onChange; private _onTouched; /** Effective disabled state (input OR form-driven) */ readonly isEffectivelyDisabled: _angular_core.Signal; /** CSS classes for the wrapper element */ readonly wrapperClasses: _angular_core.Signal; /** Flatten items into a renderable list */ readonly flatItems: _angular_core.Signal[]>; /** Filtered items based on search query */ readonly filteredItems: _angular_core.Signal[]>; /** All selectable (non-disabled) option values */ readonly allSelectableValues: _angular_core.Signal; /** The display string shown on the trigger button */ readonly displayValue: _angular_core.Signal; /** Number of selected items (for compact counter) */ readonly selectedCount: _angular_core.Signal; /** Whether the clear button should be visible */ readonly showClear: _angular_core.Signal; /** Viewport height: capped to VIEWPORT_HEIGHT_PX, shrinks for small lists */ readonly viewportHeight: _angular_core.Signal; /** * Whether all non-disabled children of a section are selected. Disabled * children are ignored so the header state stays aligned with what a click * on the section checkbox will actually toggle. */ readonly isSectionFullySelected: (sectionTitle: string) => boolean; /** Whether a section's non-disabled children are partially selected. */ readonly isSectionPartiallySelected: (sectionTitle: string) => boolean; readonly overlayPositions: ConnectedPosition[]; /** Width of the trigger (to match overlay width) */ readonly triggerWidth: _angular_core.WritableSignal; constructor(); open(): void; close(): void; /** Fully reset the combobox: clear value, search query, and close the panel. */ reset(): void; toggle(): void; onTriggerKeydown(event: KeyboardEvent): void; onPanelKeydown(event: KeyboardEvent): void; selectOption(optionValue: T): void; selectAll(): void; clearSelection(): void; onClear(event: MouseEvent): void; toggleSection(sectionTitle: string): void; onSearchInput(event: Event): void; onSearchKeydown(event: KeyboardEvent): void; onOverlayOutsideClick(): void; onOverlayAttached(): void; /** Coerce the current value into an array (safe for .some/.filter/.every). */ private _currentValueAsArray; writeValue(val: T | T[] | null): void; registerOnChange(fn: (val: T | T[] | null) => void): void; registerOnTouched(fn: () => void): void; setDisabledState(isDisabled: boolean): void; readonly isFlatSection: typeof isFlatSection; readonly isFlatOption: typeof isFlatOption; readonly itemSizePx = 48; trackByFlatItem(_index: number, item: FlatItem): string; /** Set of currently selected values, recomputed reactively for OnPush */ readonly selectedValues: _angular_core.Signal; /** Whether a given option value is currently selected */ isOptionSelected(optionValue: T): boolean; private _updateTriggerWidth; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-combobox", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "multiSearch": { "alias": "multiSearch"; "required": false; "isSignal": true; }; "showActions": { "alias": "showActions"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "canSelectAll": { "alias": "canSelectAll"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "selectAllText": { "alias": "selectAllText"; "required": false; "isSignal": true; }; "clearText": { "alias": "clearText"; "required": false; "isSignal": true; }; "selectedSuffix": { "alias": "selectedSuffix"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "showNoResultText": { "alias": "showNoResultText"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "opened": "opened"; "closed": "closed"; "searched": "searched"; }, never, never, true, never>; } /** * Harness for a single option inside the combobox dropdown. */ declare class MozComboboxOptionHarness extends ComponentHarness { static hostSelector: string; getLabel(): Promise; isSelected(): Promise; isDisabled(): Promise; select(): Promise; } /** * Harness for the McCombobox component. * * Usage: * ```ts * const harness = await loader.getHarness(McComboboxHarness); * await harness.open(); * await harness.selectOption({ label: 'Option 1' }); * expect(await harness.getDisplayValue()).toBe('Option 1'); * ``` */ declare class MozComboboxHarness extends ComponentHarness { static hostSelector: string; private _getTrigger; private _getClearButton; private _getSearchInput; open(): Promise; close(): Promise; isOpen(): Promise; getDisplayValue(): Promise; getPlaceholder(): Promise; getOptions(): Promise; selectOption(filter: { label: string; }): Promise; clear(): Promise; search(query: string): Promise; isDisabled(): Promise; isInvalid(): Promise; isReadonly(): Promise; getSelectedCount(): Promise; } interface TreeNode { id: string | number; data: T; children?: TreeNode[]; hasChildren?: boolean; checked?: boolean; disabled?: boolean; type?: string; } interface FlatNode { node: TreeNode; depth: number; parentId: string | number | null; siblingCount: number; posInSet: number; } interface TreeNodeContext { $implicit: TreeNode; depth: number; isExpanded: boolean; isSelected: boolean; isIndeterminate: boolean; isLoading: boolean; isDisabled: boolean; } type TreeSelectionMode = 'none' | 'checkbox' | 'radio'; type LoadChildrenFn = (node: TreeNode) => rxjs.Observable[]>; declare class TreeStateService { readonly expandedIds: _angular_core.WritableSignal>; readonly loadingIds: _angular_core.WritableSignal>; readonly internalNodes: _angular_core.WritableSignal[]>; readonly loadChildrenFn: _angular_core.WritableSignal | null>; /** * Parent IDs for which children have been patched in (via lazy-load). * Grows monotonically — consumers diff against their own "processed" set. * Not emitted for statically-populated children present at init. */ readonly loadedParentIds: _angular_core.WritableSignal>; readonly flatVisibleNodes: _angular_core.Signal[]>; private _flatten; setExpanded(ids: Set): void; toggleExpanded(id: string | number): void; expandAndLoad(node: TreeNode): Observable; addLoading(id: string | number): void; removeLoading(id: string | number): void; patchChildren(nodeId: string | number, children: TreeNode[]): void; private _patchNode; findNode(nodeId: string | number): TreeNode | null; private _findNodeRecursive; findParentId(nodeId: string | number): string | number | null; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class TreeSelectionService { private readonly stateService; readonly selectedIds: _angular_core.WritableSignal>; readonly selectionMode: _angular_core.WritableSignal; readonly rootNodes: _angular_core.WritableSignal[]>; readonly canSelectFn: _angular_core.WritableSignal<((node: TreeNode) => boolean) | null>; setSelectedIds(ids: Set): void; setMode(mode: TreeSelectionMode): void; setRootNodes(nodes: TreeNode[]): void; setCanSelect(fn: ((node: TreeNode) => boolean) | null): void; canSelect(node: TreeNode): boolean; isSelected(id: string | number): boolean; /** * A node is considered disabled only by its own `disabled` flag — a disabled * parent does not propagate the state to its descendants. Children of a * disabled parent remain individually interactable; the parent itself just * has its bulk "toggle all" action locked. This mirrors the combobox's * disabled-section semantics. */ isDisabled(node: TreeNode): boolean; /** * A node is indeterminate when it has loaded children AND at least one * descendant is selected without the node being fully checked. Disabled * descendants count so a pre-selected disabled leaf still surfaces on the * parent (useful when the parent itself is also disabled). */ isIndeterminate(node: TreeNode): boolean; /** * A node is checked when: * - Leaf node (no children or children not loaded): its ID is in selectedIds * - Parent with loaded children: ALL leaf descendants are selected */ isCheckedComputed(node: TreeNode): boolean; /** * Select a node: add all leaf descendant IDs (or the node's own ID if leaf). */ selectNode(node: TreeNode): void; /** * Deselect a node: remove all leaf descendant IDs (or the node's own ID if leaf). * Also remove the node's own ID in case it's in the set from external sources. */ deselectNode(node: TreeNode): void; toggleNode(node: TreeNode): void; /** * Called when children are loaded for a node. * - If parent ID was in selectedIds: replace it with children's leaf IDs (propagate down). * - If parent ID was NOT in selectedIds: remove any orphan children IDs that * may have been left from a prior bulk operation (e.g. Select All → deselect parent). */ propagateOnChildrenLoaded(parentId: string | number): void; /** * Collect leaf-level IDs (terminal nodes that have no loaded children). * Returns empty array if the node itself is a leaf. * When `includeDisabled` is true, disabled descendants are also collected — * used by the indeterminate computation so pre-selected disabled leaves * count toward a parent's state. */ private _collectLeafIds; /** * Collect ALL descendant IDs (both parents and leaves) for thorough cleanup on deselect. */ private _collectAllDescendantIds; readonly allSelectedIds: _angular_core.Signal>; private _resolveNode; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class TreeKeyboardService { private readonly state; private readonly selection; readonly focusedNodeId: _angular_core.WritableSignal; initFocus(): void; handleKeydown(event: KeyboardEvent): void; private _setFocusAndScroll; private _hasChildren; private _expandSiblings; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration>; } declare class MozTreeNodeTemplateDirective { readonly templateRef: TemplateRef; readonly type: _angular_core.InputSignal; constructor(templateRef: TemplateRef); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class MozTreeComponent { protected readonly stateService: TreeStateService; protected readonly selectionService: TreeSelectionService; protected readonly keyboardService: TreeKeyboardService; readonly nodes: _angular_core.InputSignal[]>; readonly selectionMode: _angular_core.InputSignal; readonly expandedIds: _angular_core.InputSignal>; readonly selectedIds: _angular_core.InputSignal>; readonly loadChildren: _angular_core.InputSignal | null>; readonly canSelect: _angular_core.InputSignal<((node: TreeNode) => boolean) | null>; readonly indentSize: _angular_core.InputSignal; readonly virtualScroll: _angular_core.InputSignal; readonly virtualScrollThreshold: _angular_core.InputSignal; readonly rowHeight: _angular_core.InputSignal; readonly viewportHeight: _angular_core.InputSignal; readonly _defaultTemplate: _angular_core.Signal; readonly _typedTemplates: _angular_core.Signal; readonly nodeTemplate: _angular_core.Signal> | null>; readonly nodeTemplates: _angular_core.Signal>> | null>; readonly expandedIdsChange: _angular_core.OutputEmitterRef>; readonly selectionChange: _angular_core.OutputEmitterRef>; readonly useVirtualScroll: _angular_core.Signal; readonly itemSize: _angular_core.Signal; constructor(); onTreeKeydown(event: KeyboardEvent): void; onTreeFocus(): void; onExpandChange(): void; onSelectionChange(ids: Set): void; expandPath(path: Array): Promise; scrollToNode(nodeId: string | number): void; expandAll(): void; collapseAll(): void; trackNode(_index: number, node: TreeNode): string | number; trackFlatNode(_index: number, flat: FlatNode): string | number; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; "canSelect": { "alias": "canSelect"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "virtualScrollThreshold": { "alias": "virtualScrollThreshold"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": false; "isSignal": true; }; }, { "expandedIdsChange": "expandedIdsChange"; "selectionChange": "selectionChange"; }, ["_defaultTemplate", "_typedTemplates"], never, true, never>; } declare class MozTreeNodeComponent { protected readonly stateService: TreeStateService; protected readonly selectionService: TreeSelectionService; protected readonly keyboardService: TreeKeyboardService; readonly node: _angular_core.InputSignal>; readonly depth: _angular_core.InputSignal; readonly selectionMode: _angular_core.InputSignal; readonly indentSize: _angular_core.InputSignal; readonly nodeTemplate: _angular_core.InputSignal> | null>; readonly nodeTemplates: _angular_core.InputSignal>> | null>; readonly loadChildren: _angular_core.InputSignal | null>; readonly ancestors: _angular_core.InputSignal[]>; readonly flat: _angular_core.InputSignal; readonly noResultText: _angular_core.InputSignal; readonly expandChange: _angular_core.OutputEmitterRef; readonly selectionChange: _angular_core.OutputEmitterRef>; readonly isExpanded: _angular_core.Signal; readonly isLoading: _angular_core.Signal; readonly isDisabled: _angular_core.Signal; readonly isSelected: _angular_core.Signal; readonly isIndeterminate: _angular_core.Signal; readonly isFocused: _angular_core.Signal; readonly isSelectable: _angular_core.Signal; readonly hasChildren: _angular_core.Signal; readonly resolvedTemplate: _angular_core.Signal> | null>; readonly templateContext: _angular_core.Signal>; readonly indentPx: _angular_core.Signal; readonly ancestorsWithSelf: _angular_core.Signal[]>; readonly radioName = "moz-tree-radio-group"; readonly resolvedChildren: _angular_core.Signal[]>; onHeaderClick(): void; onToggleExpand(): void; onCheckboxChange(event: Event): void; onRadioChange(event: Event): void; private _findNode; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "moz-tree-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; "nodeTemplates": { "alias": "nodeTemplates"; "required": false; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; "ancestors": { "alias": "ancestors"; "required": false; "isSignal": true; }; "flat": { "alias": "flat"; "required": false; "isSignal": true; }; "noResultText": { "alias": "noResultText"; "required": false; "isSignal": true; }; }, { "expandChange": "expandChange"; "selectionChange": "selectionChange"; }, never, never, true, never>; } export { ACTION_LISTBOX_CONFIG, ActionListboxContainerComponent, ActionListboxRef, BuiltInMenuComponent, CellSelectionEngine, CellValidationEngine, ColumnReorderEngine, ColumnResizeEngine, DEFAULT_ACTION_LISTBOX_CONFIG, DEFAULT_FORMULA_FUNCTIONS, DEFAULT_GRID_OPTIONS, DEFAULT_MODAL_CONFIG, DEFAULT_OPERATORS, DEFAULT_OPERATOR_PER_TYPE, DEFAULT_TOASTER_CONFIG, DRAWER_CONFIG, DRAWER_DATA, DrawerContainerComponent, ExpandableRowEngine, ExportEngine, FilterEngine, FormulaEngine, FormulaValues, GridEngine, GridGroupDrawerComponent, GridSettingsDrawerComponent, GridStateManager, GroupEngine, HorizontalVirtualScrollEngine, InfiniteScrollEngine, InlineEditEngine, KeyboardEngine, MODAL_CONFIG, MODAL_DATA, MozAccordionComponent, MozAccordionContentComponent, MozAccordionHeaderComponent, MozAccordionPanelComponent, MozActionBottomBarComponent, MozActionListboxComponent, MozActionListboxTriggerDirective, MozAvatarComponent, MozBreadcrumbComponent, MozButtonComponent, MozCalloutComponent, MozCarouselComponent, MozCheckListMenuComponent, MozCheckboxComponent, MozCheckboxGroupComponent, MozCircularProgressBarComponent, MozComboboxComponent, MozComboboxHarness, MozComboboxOptionHarness, MozCustomFilterHostDirective, MozDatepickerComponent, MozDividerComponent, MozDrawerComponent, MozDrawerFooterDirective, MozDrawerRef, MozDrawerService, MozFieldComponent, MozFieldGroupComponent, MozFileUploaderComponent, MozFileUploaderItemComponent, MozFlagComponent, MozGridBodyComponent, MozGridCellComponent, MozGridColumnDef, MozGridColumnVisibilityPanelComponent, MozGridComponent, MozGridCustomFilter, MozGridDetailRowComponent, MozGridEmptyDef, MozGridFooterComponent, MozGridGroupRowComponent, MozGridHeaderCellComponent, MozGridHeaderComponent, MozGridHeaderMenuComponent, MozGridLoadingIndicatorComponent, MozGridRowComponent, MozGridToolbarDef, MozIconButtonComponent, MozKpiComponent, MozLinearProgressBarBufferComponent, MozLinearProgressBarPercentageComponent, MozLinkComponent, MozLoaderComponent, MozLoadingOverlayComponent, MozModalComponent, MozModalFooterDirective, MozModalRef, MozModalService, MozNavigationIndicatorComponent, MozNumberBadgeComponent, MozOverlayComponent, MozPageHeaderComponent, MozPaginationComponent, MozPasswordInputDirective, MozPhoneNumberComponent, MozPincodeInputComponent, MozPopoverComponent, MozPopoverFooterDirective, MozPopoverTriggerDirective, MozQuantitySelectorComponent, MozRadioComponent, MozRadioGroupComponent, MozSegmentedControlComponent, MozSelectComponent, MozSidebarComponent, MozStarRatingComponent, MozStatusBadgeComponent, MozStatusDotComponent, MozStatusMessageComponent, MozStatusNotificationComponent, MozStepperBottomBarComponent, MozStepperCompactComponent, MozStepperInlineComponent, MozStepperStackedComponent, MozTabComponent, MozTabsComponent, MozTagComponent, MozTextInput, MozTextarea, MozTileComponent, MozTileExpandableComponent, MozTileSelectableComponent, MozToasterComponent, MozToasterRef, MozToasterService, MozToggleComponent, MozTooltipComponent, MozTooltipDirective, MozTreeComponent, MozTreeNodeComponent, MozTreeNodeTemplateDirective, OPERATOR_LABELS, POPOVER_CONFIG, POPOVER_DATA, PaginationEngine, PopoverContainerComponent, PopoverRef, PopoverService, RANGE_OPERATORS, RowSelectionEngine, SortEngine, StatePersistenceEngine, TOASTER_CONFIG, TreeEngine, TreeKeyboardService, TreeSelectionService, TreeStateService, VALUELESS_OPERATORS, addressToA1, firstError, generateConditionId, isConditionComplete, isSection, toBoolean, toNumber, toStringValue, trackByField, trackDisplayRow }; export type { ActionListboxConfig, ActionListboxPosition, ActiveFilter, BooleanOperator, BulkCellChange, BulkCopyEvent, BulkDeleteEvent, BulkEditEvent, BulkPasteEvent, CellAddress, CellCoord, CellEditCancelEvent, CellEditEvent, CellEditState, CellEditorType, CellError, CellRange, CellSelectionEvent, ColumnDef, ColumnFreezeEvent, ColumnReorderEvent, ColumnResizeEvent, ColumnSearchToggleEvent, ColumnStateEntry, ColumnVisibilityEvent, DateOperator, DisplayRow, ExportOptions, FillDownEvent, FilterApplyMode, FilterChangeReason, FilterColumnDescriptor, FilterCombinator, FilterCondition, FilterDataType, FilterDrawerData, FilterDrawerResult, FilterEvent, FilterMode, FilterModel, FilterOperator, FilterValue, FlatNode, FormulaArity, FormulaChangeEvent, FormulaDataSource, FormulaError, FormulaErrorEvent, FormulaEvalContext, FormulaFunctionDocs, FormulaFunctionImpl, FormulaFunctionRegistry, FormulaValue, GridDensity, GridEmptyContext, GridEmptyKind, GridEventMap, GridEventType, GridExportEvent, GridOptions, GridPlugin, GridSettingsData, GridSettingsResult, GridToolbarSlot, GroupDrawerData, GroupDrawerResult, GroupEntry, GroupEvent, GroupRow, HeaderMenuActionId, HeaderMenuConfig, KeyboardActions, LoadChildrenFn, LoadMoreEvent, LoadingStrategy, MozActionListItem, MozActionListItemAppearance, MozAvatarSize, MozBreadcrumbAppearance, MozBreadcrumbLink, MozBuiltInMenuItem, MozBuiltInMenuItemTarget, MozButtonAppearance, MozButtonIconPosition, MozButtonSize, MozButtonType, MozCalloutVariant, MozCheckListMenuItem, MozCircularProgessBarSize, MozComboboxItem, MozComboboxOption, MozComboboxSection, MozComboboxSize, MozDatepickerSize, MozDividerAppearance, MozDividerOrientation, MozDividerSize, MozDrawerConfig, MozDrawerPosition, MozFileUploaderFormat, MozFileUploaderItemFormat, MozFlagType, MozIconButtonAppearance, MozIconButtonSize, MozIconButtonType, MozKpiSize, MozKpiStatus, MozKpiTrend, MozLinearProgressBarBufferSize, MozLinkAppearance, MozLinkIconPosition, MozLinkSize, MozLoaderAppearance, MozLoaderSize, MozNavigationIndicatorAction, MozNumberBadgeAppearance, MozNumberBadgeSize, MozPageHeaderScope, MozPhoneNumberCountry, MozPhoneNumberSize, MozPhoneNumberValue, MozPincodeLength, MozPopoverAppearance, MozPopoverPosition, MozPopoverSize, MozQuantitySelectorSize, MozSegmentedControlSize, MozSegmentedItem, MozSelectOption, MozSelectSize, MozSelectValue, MozSidebarItem, MozSidebarSubItem, MozStarRatingAppearance, MozStarRatingSize, MozStatusBadgeStatus, MozStatusDotSize, MozStatusDotStatus, MozStatusMessageStatus, MozStatusNotificationStatus, MozStepperBottomBarStep, MozStepperInlineStep, MozStepperStackedStep, MozTabItem, MozTagSize, MozTagType, MozTextInputSize, MozTileAppearance, MozTileExpandableTrigger, MozTileInputPosition, MozTileInputVerticalPosition, MozTileSelectableAppearance, MozTileSelectableType, MozToasterPosition, MozToasterRole, MozToasterStatus, MozToggleSize, MozTooltipPosition, NumberOperator, PageEvent, PaginationState, PersistedGridState, PopoverConfig, PopoverTriggerMode, RowSelectionEvent, SelectAllMode, SetOperator, SortDef, SortDirection, SortEvent, TextOperator, TreeDisplayRow, TreeNode, TreeNodeConfig, TreeNodeContext, TreeSelectionMode };