mn-angular-lib 0.0.43 → 0.0.45

package/types/mn-angular-lib.d.ts

@@ -1,13 +1,14 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Provider, TemplateRef, OnInit } from '@angular/core';
+import { InjectionToken, Provider, TemplateRef, OnInit, Type, ComponentRef, AfterViewInit, OnDestroy, ElementRef, QueryList, ChangeDetectorRef, ViewContainerRef, EventEmitter, PipeTransform } from '@angular/core';
+export { TemplateRef, Type } from '@angular/core';
 import * as tailwind_variants from 'tailwind-variants';
 import { VariantProps } from 'tailwind-variants';
 import * as rxjs from 'rxjs';
-import { Observable } from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
 import * as mn_angular_lib from 'mn-angular-lib';
 import * as _angular_forms from '@angular/forms';
-import { ValidationErrors, NgControl, AbstractControl } from '@angular/forms';
-import { HttpClient } from '@angular/common/http';
+import { ValidationErrors, NgControl, AbstractControl, FormGroup, FormBuilder } from '@angular/forms';
+import { HttpClient, HttpStatusCode, HttpHeaders, HttpErrorResponse, HttpResponse, HttpParams } from '@angular/common/http';
 
 declare const mnAlertVariants: tailwind_variants.TVReturnType<{
     kind: {
@@ -363,6 +364,10 @@ interface MnInputBaseProps {
     name?: string;
     /** Type of input field (text, email, date, etc.) */
     type: MnInputType;
+    /** Label text (overrides uiConfig.label when provided) */
+    label?: string;
+    /** Placeholder text (overrides uiConfig.placeholder when provided) */
+    placeholder?: string;
     /** Size variant of the input field (default: 'md') */
     size?: MnInputVariants['size'];
     /** Border radius variant (default: 'md') */
@@ -1232,91 +1237,2025 @@ declare class MnTextarea implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<MnTextarea, "mn-lib-textarea", never, { "props": { "alias": "props"; "required": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * Types for mn-lib configuration.
- */
-interface MnConfigFile {
-    /**
-     * Base defaults by component name. Each value is a plain object with inputs/options for that component.
-     */
-    defaults: Record<string, unknown>;
-    /**
-     * Nested object tree keyed by section names. Leaf nodes may contain
-     * component-name keys (component override objects) and keys starting with '#'
-     * representing instance-id overrides.
-     */
-    overrides: unknown;
-}
+declare const mnCheckboxVariants: tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, "accent-brand-500 cursor-pointer", {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, "accent-brand-500 cursor-pointer", unknown, unknown, undefined>>;
+type MnCheckboxVariants = VariantProps<typeof mnCheckboxVariants>;
 
-declare class MnConfigService {
-    private readonly http;
-    private _config;
-    private _debugMode;
-    constructor(http: HttpClient);
-    /**
-     * Load the configuration JSON from the provided URL and cache it in memory.
-     * Consumers should typically call this via the APP_INITIALIZER helper.
-     */
-    load(url: string, debugMode?: boolean): Promise<void>;
-    /**
-     * Resolve a configuration object for a component, optionally scoped to a section path
-     * and optionally overridden by an instance id.
-     */
-    resolve<T extends object = any>(componentName: string, sectionPath?: string[], instanceId?: string): T;
-    /**
-     * Walk the overrides nested object using the provided section path and return the leaf node.
-     * If any segment is missing or the current node is not a plain object, returns undefined.
-     */
-    walkOverrides(overridesRoot: unknown, sectionPath: string[]): unknown | undefined;
-    /**
-     * Deep merge two plain-object trees. Arrays and non-plain values are replaced by the patch.
-     * Does not mutate inputs; returns a new object.
-     */
-    deepMerge<A extends Record<string, any>, B extends Record<string, any>>(base: A, patch: B): A & B;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MnConfigService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MnConfigService>;
+type MnCheckboxErrorMessageData = string | ((args: any, errors: ValidationErrors) => string);
+type MnCheckboxErrorMessagesData = Partial<Record<string, MnCheckboxErrorMessageData>>;
+interface MnCheckboxProps {
+    /** Unique identifier for the checkbox element (required for accessibility) */
+    id: string;
+    /** Name attribute for the checkbox element (used in form submission) */
+    name?: string;
+    /** Label text displayed next to the checkbox */
+    label?: string;
+    /** Size variant of the checkbox (default: 'md') */
+    size?: MnCheckboxVariants['size'];
+    /** Border radius variant (default: 'sm') */
+    borderRadius?: MnCheckboxVariants['borderRadius'];
+    /** Custom error messages mapped by validator error key */
+    errorMessages?: MnCheckboxErrorMessagesData;
+    /** Fallback error message when no specific message is found for an error */
+    defaultErrorMessage?: string;
+    /** Priority order for displaying errors when multiple validation errors exist */
+    errorPriority?: string[];
+    /** Whether to use built-in default error messages (default: true) */
+    useBuiltInErrorMessages?: boolean;
+    /** Whether to display all validation errors or just the first/priority error (default: false) */
+    showAllErrors?: boolean;
+}
+interface MnCheckboxUIConfig {
+    /** Label text displayed next to the checkbox */
+    label?: string;
+    /** ARIA label for screen readers (falls back to label if not provided) */
+    ariaLabel?: string;
 }
 
-/**
- * Provides an APP_INITIALIZER that loads the mn-lib configuration from the given URL
- * during application bootstrap. The consuming application is responsible for providing
- * HttpClient (e.g., via HttpClientModule or provideHttpClient()).
- */
-declare function provideMnConfig(url: string, debugMode?: boolean): Provider[];
+declare const MN_CHECKBOX_CONFIG: InjectionToken<MnCheckboxUIConfig>;
+declare class MnCheckbox implements OnInit {
+    ngControl: NgControl;
+    protected uiConfig: MnCheckboxUIConfig;
+    props: MnCheckboxProps;
+    private readonly configService;
+    private readonly sectionPath;
+    private readonly explicitInstanceId;
+    value: boolean;
+    isDisabled: boolean;
+    private onChange;
+    private onTouched;
+    private readonly builtInErrorMessages;
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    private resolveConfig;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleChange(checked: boolean): void;
+    handleBlur(): void;
+    get control(): _angular_forms.AbstractControl<any, any, any> | null;
+    get showError(): boolean;
+    private pickErrorKey;
+    protected isRequired(): boolean;
+    private resolveErrorMessageForKey;
+    get errorMessages(): string[];
+    get errorMessage(): string | null;
+    get resolvedId(): string;
+    get resolvedName(): string | null;
+    get checkboxClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnCheckbox, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnCheckbox, "mn-lib-checkbox", never, { "props": { "alias": "props"; "required": true; }; }, {}, never, never, true, never>;
+}
 
-/**
- * Helper to provide a resolved, typed component config via DI.
- *
- * Usage in a component/module providers:
- *   const MY_CFG = new InjectionToken<MyCfg>('MY_CFG');
- *   providers: [ provideMnComponentConfig(MY_CFG, 'my-component') ]
- * Then in the component:
- *   readonly cfg = inject(MY_CFG)
- */
-declare function provideMnComponentConfig<T extends object>(token: InjectionToken<T>, componentName: string, initial?: Partial<T>): Provider;
+declare const mnDatetimeVariants: tailwind_variants.TVReturnType<{
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, "bg-white border-1 border-gray-500 placeholder-gray-500 text-sm", {
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, "bg-white border-1 border-gray-500 placeholder-gray-500 text-sm", unknown, unknown, undefined>>;
+type MnDatetimeVariants = VariantProps<typeof mnDatetimeVariants>;
 
+type MnDatetimeErrorMessageData = string | ((args: any, errors: ValidationErrors) => string);
+type MnDatetimeErrorMessagesData = Partial<Record<string, MnDatetimeErrorMessageData>>;
 /**
- * Represents the current section path based on nested mn-section directives.
- */
-declare const MN_SECTION_PATH: InjectionToken<string[]>;
-/**
- * Represents the current component instance id provided by [mn-instance].
+ * Supported datetime input modes.
+ * - 'date': Date only (YYYY-MM-DD)
+ * - 'time': Time only (HH:mm)
+ * - 'datetime-local': Date and time combined (YYYY-MM-DDTHH:mm)
  */
-declare const MN_INSTANCE_ID: InjectionToken<string | null>;
-
-declare class MnSectionDirective {
-    /** Section name contributed by this DOM node to the section path */
-    mnSection: string | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MnSectionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MnSectionDirective, "[mn-section]", never, { "mnSection": { "alias": "mn-section"; "required": false; }; }, {}, never, never, true, never>;
+type MnDatetimeMode = 'date' | 'time' | 'datetime-local';
+interface MnDatetimeProps {
+    /** Unique identifier for the datetime element (required for accessibility) */
+    id: string;
+    /** Name attribute for the datetime element (used in form submission) */
+    name?: string;
+    /** Label text displayed above the datetime field */
+    label?: string;
+    /** Placeholder text (overrides uiConfig.placeholder when provided) */
+    placeholder?: string;
+    /** Datetime input mode (default: 'datetime-local') */
+    mode?: MnDatetimeMode;
+    /** Minimum allowed date/time value (ISO 8601 format) */
+    min?: string;
+    /** Maximum allowed date/time value (ISO 8601 format) */
+    max?: string;
+    /** Step interval in seconds (e.g., 60 for minute precision, 1 for second precision) */
+    step?: number;
+    /** Size variant of the datetime field (default: 'md') */
+    size?: MnDatetimeVariants['size'];
+    /** Border radius variant (default: 'md') */
+    borderRadius?: MnDatetimeVariants['borderRadius'];
+    /** Shadow variant for the datetime field */
+    shadow?: MnDatetimeVariants['shadow'];
+    /** Whether the datetime field should take full width of its container */
+    fullWidth?: MnDatetimeVariants['fullWidth'];
+    /** Custom error messages mapped by validator error key */
+    errorMessages?: MnDatetimeErrorMessagesData;
+    /** Fallback error message when no specific message is found for an error */
+    defaultErrorMessage?: string;
+    /** Priority order for displaying errors when multiple validation errors exist */
+    errorPriority?: string[];
+    /** Whether to use built-in default error messages (default: true) */
+    useBuiltInErrorMessages?: boolean;
+    /** Whether to display all validation errors or just the first/priority error (default: false) */
+    showAllErrors?: boolean;
+}
+interface MnDatetimeUIConfig {
+    /** Label text displayed above the datetime field */
+    label?: string;
+    /** Placeholder text shown inside the datetime field when empty */
+    placeholder?: string;
+    /** ARIA label for screen readers (falls back to label if not provided) */
+    ariaLabel?: string;
 }
 
-declare class MnInstanceDirective {
-    /** Instance id for targeting per-component instance overrides */
-    mnInstance: string | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MnInstanceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MnInstanceDirective, "[mn-instance]", never, { "mnInstance": { "alias": "mn-instance"; "required": false; }; }, {}, never, never, true, never>;
+declare const MN_DATETIME_CONFIG: InjectionToken<MnDatetimeUIConfig>;
+declare class MnDatetime implements OnInit {
+    ngControl: NgControl;
+    protected uiConfig: MnDatetimeUIConfig;
+    props: MnDatetimeProps;
+    private readonly configService;
+    private readonly sectionPath;
+    private readonly explicitInstanceId;
+    value: string | null;
+    isDisabled: boolean;
+    private onChange;
+    private onTouched;
+    private readonly builtInErrorMessages;
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    private resolveConfig;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInput(raw: string): void;
+    handleBlur(): void;
+    get control(): _angular_forms.AbstractControl<any, any, any> | null;
+    get showError(): boolean;
+    private pickErrorKey;
+    protected isRequired(): boolean;
+    private resolveErrorMessageForKey;
+    get errorMessages(): string[];
+    get errorMessage(): string | null;
+    get resolvedId(): string;
+    get resolvedName(): string | null;
+    get resolvedMode(): MnDatetimeMode;
+    get inputClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnDatetime, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnDatetime, "mn-lib-datetime", never, { "props": { "alias": "props"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare const mnMultiSelectVariants: tailwind_variants.TVReturnType<{
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, "bg-white border-1 border-gray-500 text-sm cursor-pointer", {
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    shadow: {
+        true: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    borderRadius: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        two_xl: string;
+        three_xl: string;
+        four_xl: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+}, undefined, "bg-white border-1 border-gray-500 text-sm cursor-pointer", unknown, unknown, undefined>>;
+type MnMultiSelectVariants = VariantProps<typeof mnMultiSelectVariants>;
+
+type MnMultiSelectErrorMessageData = string | ((args: any, errors: ValidationErrors) => string);
+type MnMultiSelectErrorMessagesData = Partial<Record<string, MnMultiSelectErrorMessageData>>;
+interface MnMultiSelectOption<TValue = unknown> {
+    /** Display label for the option */
+    label: string;
+    /** Value associated with the option */
+    value: TValue;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+}
+interface MnMultiSelectProps<TValue = unknown> {
+    /** Unique identifier for the multi-select element (required for accessibility) */
+    id: string;
+    /** Name attribute for the multi-select element (used in form submission) */
+    name?: string;
+    /** Label text displayed above the multi-select */
+    label?: string;
+    /** Placeholder text shown when no options are selected */
+    placeholder?: string;
+    /** Available options to select from */
+    options: MnMultiSelectOption<TValue>[];
+    /** Whether to show a search/filter input (default: false) */
+    searchable?: boolean;
+    /** Placeholder text for the search input */
+    searchPlaceholder?: string;
+    /** Maximum number of items that can be selected (undefined = unlimited) */
+    maxSelections?: number;
+    /** Size variant of the multi-select (default: 'md') */
+    size?: MnMultiSelectVariants['size'];
+    /** Border radius variant (default: 'md') */
+    borderRadius?: MnMultiSelectVariants['borderRadius'];
+    /** Shadow variant for the multi-select */
+    shadow?: MnMultiSelectVariants['shadow'];
+    /** Whether the multi-select should take full width of its container */
+    fullWidth?: MnMultiSelectVariants['fullWidth'];
+    /** Custom error messages mapped by validator error key */
+    errorMessages?: MnMultiSelectErrorMessagesData;
+    /** Fallback error message when no specific message is found for an error */
+    defaultErrorMessage?: string;
+    /** Priority order for displaying errors when multiple validation errors exist */
+    errorPriority?: string[];
+    /** Whether to use built-in default error messages (default: true) */
+    useBuiltInErrorMessages?: boolean;
+    /** Whether to display all validation errors or just the first/priority error (default: false) */
+    showAllErrors?: boolean;
+}
+interface MnMultiSelectUIConfig {
+    /** Label text displayed above the multi-select */
+    label?: string;
+    /** Placeholder text shown when no options are selected */
+    placeholder?: string;
+    /** ARIA label for screen readers (falls back to label if not provided) */
+    ariaLabel?: string;
+}
+
+declare const MN_MULTI_SELECT_CONFIG: InjectionToken<MnMultiSelectUIConfig>;
+declare class MnMultiSelect implements OnInit {
+    ngControl: NgControl;
+    protected uiConfig: MnMultiSelectUIConfig;
+    props: MnMultiSelectProps;
+    private readonly configService;
+    private readonly sectionPath;
+    private readonly explicitInstanceId;
+    private readonly elRef;
+    /** Currently selected values */
+    selectedValues: unknown[];
+    isOpen: boolean;
+    isDisabled: boolean;
+    searchTerm: string;
+    private onChange;
+    private onTouched;
+    private readonly builtInErrorMessages;
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    private resolveConfig;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggle(): void;
+    onDocumentClick(event: Event): void;
+    toggleOption(option: MnMultiSelectOption): void;
+    removeOption(option: MnMultiSelectOption, event: Event): void;
+    isSelected(option: MnMultiSelectOption): boolean;
+    isMaxReached(option: MnMultiSelectOption): boolean;
+    onSearch(term: string): void;
+    get filteredOptions(): MnMultiSelectOption[];
+    get selectedOptions(): MnMultiSelectOption[];
+    handleBlur(): void;
+    get control(): _angular_forms.AbstractControl<any, any, any> | null;
+    get showError(): boolean;
+    private pickErrorKey;
+    protected isRequired(): boolean;
+    private resolveErrorMessageForKey;
+    get errorMessages(): string[];
+    get errorMessage(): string | null;
+    get resolvedId(): string;
+    get resolvedName(): string | null;
+    get triggerClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnMultiSelect, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnMultiSelect, "mn-lib-multi-select", never, { "props": { "alias": "props"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+interface PaginationStrategy {
+    hasMoreRows: boolean;
+    loadMore: () => Promise<void>;
+    reset?: () => void;
+}
+interface CursorPaginationStrategy extends PaginationStrategy {
+    endCursor?: string;
+}
+interface OffsetPaginationStrategy extends PaginationStrategy {
+    currentPage: number;
+    pageSize: number;
+    totalItems?: number;
+}
+interface TableRowAction<T> {
+    icon?: string;
+    label?: string;
+    cssClass?: string;
+    onClick: (row: T) => void;
+    isVisible?: (row: T) => boolean;
+    isDisabled?: (row: T) => boolean;
+}
+declare enum ColumnSortType {
+    ALPHABETICAL = "ALPHABETICAL",
+    NUMERICAL = "NUMERICAL",
+    DATE = "DATE",
+    NONE = "NONE"
+}
+interface SortState {
+    columnKey: string;
+    direction: 'asc' | 'desc';
+}
+interface TableAppearance {
+    striped?: boolean;
+    hover?: boolean;
+    compact?: boolean;
+    bordered?: boolean;
+}
+interface ColumnDefinition<T> {
+    key: string;
+    header: string | TemplateRef<any>;
+    cell: ((row: T) => string) | TemplateRef<any>;
+    sortType?: ColumnSortType;
+    getRawValueToSort?: (row: T) => any;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    hiddenBelow?: 'sm' | 'md' | 'lg';
+}
+interface TableDataSource<T> {
+    dataRows: BehaviorSubject<T[]>;
+    columns: ColumnDefinition<T>[];
+    getID: (row: T) => string;
+    emptyMessage: string;
+    emptyTemplate?: TemplateRef<any>;
+    isDataLoading: boolean;
+    canSearch: boolean;
+    searchPlaceholder?: string;
+    isInSearch?: (row: T, searchValue: string) => boolean;
+    searchForAdditionalItems?: (searchValue: string) => Promise<T[]>;
+    paginationMode?: 'none' | 'load-more' | 'paginated' | 'infinite-scroll';
+    paginationStrategy?: PaginationStrategy;
+    loadAdditionalRows?: () => Promise<T[]>;
+    defaultSort?: SortState;
+    selectionMode?: 'none' | 'single' | 'multi';
+    selectedRows?: BehaviorSubject<T[]>;
+    rowActions?: TableRowAction<T>[];
+    onRowClick?: (row: T) => void;
+    appearance?: TableAppearance;
+    toolbarTemplate?: TemplateRef<any>;
+}
+
+declare enum ModalKind {
+    WIZARD = "wizard",
+    FORM = "form",
+    CONFIRMATION = "confirmation",
+    CUSTOM = "custom"
+}
+declare enum ModalSize {
+    SM = "sm",
+    MD = "md",
+    LG = "lg",
+    XL = "xl",
+    FULL = "full"
+}
+declare enum CloseMode {
+    ALLOWED = "allowed",
+    GUARDED = "guarded",
+    DISABLED = "disabled"
+}
+declare enum BackdropMode {
+    HIDE = "hide",
+    STATIC = "static",
+    CLOSABLE = "closable"
+}
+declare enum KeyboardMode {
+    ENABLED = "enabled",
+    DISABLED = "disabled"
+}
+declare enum ModalIntent {
+    NEUTRAL = "neutral",
+    INFO = "info",
+    SUCCESS = "success",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare enum WizardFlowMode {
+    LINEAR = "linear",
+    FREE = "free"
+}
+declare enum FormLayoutMode {
+    SINGLE_COLUMN = "single-column",
+    TWO_COLUMN = "two-column",
+    INLINE = "inline"
+}
+declare enum SubmitMode {
+    ONCE = "once",
+    RETRYABLE = "retryable"
+}
+declare enum ConfirmationTone {
+    DEFAULT = "default",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare enum FieldKind {
+    TEXT = "text",
+    NUMBER = "number",
+    SELECT = "select",
+    CHECKBOX = "checkbox",
+    DATE = "date",
+    TEXTAREA = "textarea",
+    DATETIME = "datetime",
+    MULTI_SELECT = "multi-select",
+    MULTI_SELECT_TABLE = "multi-select-table",
+    SINGLE_SELECT_TABLE = "single-select-table",
+    PASSWORD = "password",
+    FILE = "file",
+    COLOR = "color",
+    RATING = "rating",
+    SLIDER = "slider",
+    CUSTOM = "custom"
+}
+declare enum FieldAppearance {
+    OUTLINE = "outline",
+    FILLED = "filled",
+    GHOST = "ghost"
+}
+declare enum SelectionMode {
+    SINGLE = "single",
+    MULTIPLE = "multiple"
+}
+declare enum OptionState {
+    ENABLED = "enabled",
+    DISABLED = "disabled"
+}
+declare enum ActionStyle {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    DANGER = "danger",
+    GHOST = "ghost"
+}
+declare enum StepState {
+    PENDING = "pending",
+    ACTIVE = "active",
+    COMPLETE = "complete",
+    DISABLED = "disabled",
+    HIDDEN = "hidden"
+}
+declare enum NavigationDirection {
+    FORWARD = "forward",
+    BACKWARD = "backward",
+    DIRECT = "direct"
+}
+declare enum ModalCloseReason {
+    COMPLETED = "completed",
+    CANCELLED = "cancelled",
+    DISMISSED = "dismissed",
+    BACKDROP = "backdrop",
+    ESCAPE = "escape",
+    PROGRAMMATIC = "programmatic",
+    GUARD_REJECTED = "guard_rejected"
+}
+declare enum ValidationStatus {
+    VALID = "valid",
+    INVALID = "invalid",
+    PENDING = "pending"
+}
+declare enum ValidationCode {
+    REQUIRED = "required",
+    MIN = "min",
+    MAX = "max",
+    PATTERN = "pattern",
+    CUSTOM = "custom"
+}
+type ModalStepId = string;
+type ModalInputMap = Record<string, unknown>;
+/**
+ * A condition function that receives the current form values and returns
+ * whether the field should be visible.
+ */
+type FieldVisibilityCondition<TModel = any> = (formValue: Partial<TModel>) => boolean;
+/**
+ * A form-level validator that receives the entire form value
+ * and returns an error map or null.
+ */
+type FormValidator<TModel = any> = (formValue: Partial<TModel>) => Record<string, string> | null;
+/**
+ * A data source that asynchronously loads options for select/multi-select fields.
+ * Can optionally depend on other field values to reload.
+ */
+interface FieldDataSource<TValue = unknown, TModel = any> {
+    /** Load options, optionally based on current form values */
+    load(formValue?: Partial<TModel>): Promise<SelectOption<TValue>[]> | SelectOption<TValue>[];
+    /** Keys of other fields that trigger a reload when their value changes */
+    dependsOn?: (keyof TModel)[];
+}
+interface ValidationResult {
+    status: ValidationStatus;
+    code?: ValidationCode;
+    message?: string;
+}
+interface StepValidator {
+    validate(): Promise<ValidationResult> | ValidationResult;
+}
+interface FieldValidator {
+    validate(value: unknown): Promise<ValidationResult> | ValidationResult;
+}
+interface StepGuard {
+    canEnter(): Promise<boolean> | boolean;
+    canExit(): Promise<boolean> | boolean;
+}
+interface ModalCloseEvent<TResult = unknown> {
+    reason: ModalCloseReason;
+    result?: TResult;
+}
+interface ModalRef<TResult = unknown> {
+    afterClosed$: Observable<ModalCloseEvent<TResult>>;
+    close(result?: TResult): void;
+    dismiss(reason: ModalCloseReason): void;
+    update(config: Partial<BaseModalConfig<TResult>>): void;
+}
+interface ModalResultHandler<TResult = unknown> {
+    handle(result: TResult): Promise<void> | void;
+}
+interface WizardStepChangeEvent {
+    previousStepId?: ModalStepId;
+    currentStepId: ModalStepId;
+    direction: NavigationDirection;
+}
+interface WizardStepChangeHandler {
+    handle(event: WizardStepChangeEvent): Promise<void> | void;
+}
+type StepBodyConfig = Type<unknown> | TemplateRef<unknown> | string;
+interface WizardStepConfig<TModel = any> {
+    id: ModalStepId;
+    title: string;
+    state?: StepState;
+    body?: StepBodyConfig;
+    fields?: FormFieldConfig<TModel>[];
+    rows?: FormRow<TModel>[];
+    fieldGroups?: FormFieldGroup<TModel>[];
+    formValidators?: FormValidator<TModel>[];
+    groupValidators?: any[];
+    initialValue?: Partial<TModel>;
+    guard?: StepGuard;
+    validators?: StepValidator[];
+    /** Condition to show/hide this entire step based on aggregated wizard data */
+    visible?: (aggregatedData: Record<ModalStepId, Record<string, any>>) => boolean;
+}
+interface WizardResult {
+    status: ModalCloseReason;
+    visitedStepIds: ModalStepId[];
+    payload?: Record<ModalStepId, Record<string, any>>;
+}
+interface SelectOption<TValue = unknown> {
+    label: string;
+    value: TValue;
+    state?: OptionState;
+}
+interface TextFieldConfig<TModel = unknown> {
+    kind: FieldKind.TEXT;
+    key: keyof TModel;
+    label: string;
+    appearance?: FieldAppearance;
+    validators?: any[];
+    asyncValidators?: any[];
+    placeholder?: string;
+    /** Whether this field is read-only (display only) */
+    readOnly?: boolean;
+    /** Whether this field is disabled */
+    disabled?: boolean;
+    /** Condition to show/hide this field based on other field values */
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface NumberFieldConfig<TModel = unknown> {
+    kind: FieldKind.NUMBER;
+    key: keyof TModel;
+    label: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface SelectFieldConfig<TModel = unknown, TValue = unknown> {
+    kind: FieldKind.SELECT;
+    key: keyof TModel;
+    label: string;
+    options: SelectOption<TValue>[];
+    selectionMode?: SelectionMode;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+    /** Async data source for loading options dynamically */
+    dataSource?: FieldDataSource<TValue, TModel>;
+}
+interface CheckboxFieldConfig<TModel = unknown> {
+    kind: FieldKind.CHECKBOX;
+    key: keyof TModel;
+    label: string;
+    defaultValue?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface DateFieldConfig<TModel = unknown> {
+    kind: FieldKind.DATE;
+    key: keyof TModel;
+    label: string;
+    placeholder?: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    minDate?: string;
+    maxDate?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface TextareaFieldConfig<TModel = unknown> {
+    kind: FieldKind.TEXTAREA;
+    key: keyof TModel;
+    label: string;
+    placeholder?: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    rows?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface DatetimeFieldConfig<TModel = unknown> {
+    kind: FieldKind.DATETIME;
+    key: keyof TModel;
+    label: string;
+    placeholder?: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    mode?: 'date' | 'time' | 'datetime-local';
+    min?: string;
+    max?: string;
+    step?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface MultiSelectFieldConfig<TModel = unknown, TValue = unknown> {
+    kind: FieldKind.MULTI_SELECT;
+    key: keyof TModel;
+    label: string;
+    options: SelectOption<TValue>[];
+    validators?: any[];
+    asyncValidators?: any[];
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    maxSelections?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+    /** Async data source for loading options dynamically */
+    dataSource?: FieldDataSource<TValue, TModel>;
+}
+interface PasswordFieldConfig<TModel = unknown> {
+    kind: FieldKind.PASSWORD;
+    key: keyof TModel;
+    label: string;
+    placeholder?: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface MultiSelectTableFieldConfig<TModel = unknown, TRow = any> {
+    kind: FieldKind.MULTI_SELECT_TABLE;
+    key: keyof TModel;
+    label: string;
+    /** The TableDataSource that powers the mn-table. selectionMode will be forced to 'multi'. */
+    tableDataSource: TableDataSource<TRow>;
+    /** Function to extract the value stored in the form from a selected row (default: getID) */
+    getRowValue?: (row: TRow) => unknown;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface SingleSelectTableFieldConfig<TModel = unknown, TRow = any> {
+    kind: FieldKind.SINGLE_SELECT_TABLE;
+    key: keyof TModel;
+    label: string;
+    /** The TableDataSource that powers the mn-table. selectionMode will be forced to 'single'. */
+    tableDataSource: TableDataSource<TRow>;
+    /** Function to extract the value stored in the form from a selected row (default: getID) */
+    getRowValue?: (row: TRow) => unknown;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface ColorFieldConfig<TModel = unknown> {
+    kind: FieldKind.COLOR;
+    key: keyof TModel;
+    label: string;
+    /** Default color value (hex string, e.g., '#ff0000') */
+    defaultValue?: string;
+    /** Predefined color swatches to show */
+    swatches?: string[];
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface RatingFieldConfig<TModel = unknown> {
+    kind: FieldKind.RATING;
+    key: keyof TModel;
+    label: string;
+    /** Maximum rating value (default: 5) */
+    max?: number;
+    /** Icon to use for rating (default: 'star') */
+    icon?: 'star' | 'heart' | 'circle';
+    /** Allow half-star ratings (default: false) */
+    allowHalf?: boolean;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface SliderFieldConfig<TModel = unknown> {
+    kind: FieldKind.SLIDER;
+    key: keyof TModel;
+    label: string;
+    /** Minimum value (default: 0) */
+    min?: number;
+    /** Maximum value (default: 100) */
+    max?: number;
+    /** Step increment (default: 1) */
+    step?: number;
+    /** Whether to show the current value label (default: true) */
+    showValue?: boolean;
+    /** Unit label displayed after the value (e.g., '%', 'px') */
+    unit?: string;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface FileFieldConfig<TModel = unknown> {
+    kind: FieldKind.FILE;
+    key: keyof TModel;
+    label: string;
+    /** Accepted file types (e.g., '.pdf,.jpg,image/*') */
+    accept?: string;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Maximum number of files (when multiple is true) */
+    maxFiles?: number;
+    validators?: any[];
+    asyncValidators?: any[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface CustomFieldConfig<TModel = unknown> {
+    kind: FieldKind.CUSTOM;
+    key: keyof TModel;
+    component: Type<unknown>;
+    inputs?: ModalInputMap;
+    label?: string;
+    visible?: FieldVisibilityCondition<TModel>;
+}
+type FormFieldConfig<TModel = unknown> = TextFieldConfig<TModel> | NumberFieldConfig<TModel> | SelectFieldConfig<TModel> | CheckboxFieldConfig<TModel> | DateFieldConfig<TModel> | TextareaFieldConfig<TModel> | DatetimeFieldConfig<TModel> | MultiSelectFieldConfig<TModel> | MultiSelectTableFieldConfig<TModel> | SingleSelectTableFieldConfig<TModel> | PasswordFieldConfig<TModel> | FileFieldConfig<TModel> | ColorFieldConfig<TModel> | RatingFieldConfig<TModel> | SliderFieldConfig<TModel> | CustomFieldConfig<TModel>;
+interface FormRowField<TModel = unknown> {
+    field: FormFieldConfig<TModel>;
+    span?: number;
+}
+interface FormRow<TModel = unknown> {
+    columns?: number;
+    fields: FormRowField<TModel>[];
+}
+interface FormFieldGroup<TModel = unknown> {
+    /** Section header title */
+    title: string;
+    /** Optional description below the section header */
+    description?: string;
+    /** Fields in this group */
+    fields: FormFieldConfig<TModel>[];
+    /** Optional rows layout for this group */
+    rows?: FormRow<TModel>[];
+    /** Condition to show/hide this entire group based on form values */
+    visible?: FieldVisibilityCondition<TModel>;
+}
+interface ConfirmationActionConfig<TResult = unknown> {
+    label: string;
+    style?: ActionStyle;
+    handler?: ModalResultHandler<TResult>;
+}
+interface CancellationActionConfig {
+    label: string;
+    style?: ActionStyle;
+    reason?: ModalCloseReason;
+}
+interface ModalFooterAction<TResult = unknown> {
+    label: string;
+    style?: ActionStyle;
+    /** Position in the footer: 'left' or 'right' (default: 'right') */
+    position?: 'left' | 'right';
+    /** Whether this action closes the modal */
+    closesModal?: boolean;
+    /** Close reason when this action closes the modal */
+    closeReason?: ModalCloseReason;
+    /** Handler called when the action is clicked */
+    handler?: (modalRef: ModalRef<TResult>) => Promise<void> | void;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+}
+interface ModalPollingConfig<TResult = unknown> {
+    /** Polling interval in milliseconds */
+    interval: number;
+    /** Function called on each poll tick */
+    onPoll: (modalRef: ModalRef<TResult>) => Promise<boolean | void> | boolean | void;
+    /** Whether to start polling immediately (default: true) */
+    autoStart?: boolean;
+    /** Maximum number of poll attempts (undefined = unlimited) */
+    maxAttempts?: number;
+}
+interface ModalI18nLabels {
+    /** Submit button label (default: 'Submit') */
+    submit?: string;
+    /** Cancel button label (default: 'Cancel') */
+    cancel?: string;
+    /** Next button label for wizard (default: 'Next') */
+    next?: string;
+    /** Back button label for wizard (default: 'Back') */
+    back?: string;
+    /** Close button label (default: 'Close') */
+    close?: string;
+    /** Complete button label for wizard (default: 'Complete') */
+    complete?: string;
+    /** Submitting state label (default: 'Submitting...') */
+    submitting?: string;
+    /** Completing state label (default: 'Completing...') */
+    completing?: string;
+    /** Loading label (default: 'Loading...') */
+    loading?: string;
+    /** Select placeholder (default: 'Select...') */
+    selectPlaceholder?: string;
+    /** File upload prompt (default: 'Click or drag files here') */
+    fileUploadPrompt?: string;
+    /** Confirm button label (default: 'Confirm') */
+    confirm?: string;
+}
+type ModalCancelHandler<TResult = unknown> = (reason: ModalCloseReason) => Promise<void> | void;
+interface BaseModalConfig<TResult = unknown> {
+    kind: ModalKind;
+    title?: string;
+    subtitle?: string;
+    description?: string;
+    size?: ModalSize;
+    closeMode?: CloseMode;
+    closeGuard?: () => Promise<boolean> | boolean;
+    backdrop?: BackdropMode;
+    keyboard?: KeyboardMode;
+    intent?: ModalIntent;
+    resultType?: TResult;
+    /** Custom footer actions (overrides default footer) */
+    footerActions?: ModalFooterAction<TResult>[];
+    /** Polling configuration for periodic async operations */
+    polling?: ModalPollingConfig<TResult>;
+    /** Handler called when the modal is cancelled or dismissed */
+    onCancel?: ModalCancelHandler<TResult>;
+    /** i18n labels for buttons and UI text */
+    i18n?: ModalI18nLabels;
+}
+/** Validator that receives aggregated data from all wizard steps before completion */
+type WizardBeforeCompleteValidator = (payload: Record<ModalStepId, Record<string, any>>) => Promise<Record<string, string> | null> | Record<string, string> | null;
+interface WizardModalConfig<TResult = WizardResult> extends BaseModalConfig<TResult> {
+    kind: ModalKind.WIZARD;
+    steps: WizardStepConfig[];
+    startStepId?: ModalStepId;
+    flow?: WizardFlowMode;
+    onStepChange?: WizardStepChangeHandler;
+    onComplete?: ModalResultHandler<TResult>;
+    /** Cross-step validators run before wizard completion */
+    onBeforeComplete?: WizardBeforeCompleteValidator[];
+}
+interface FormModalConfig<TModel = unknown, TResult = TModel> extends BaseModalConfig<TResult> {
+    kind: ModalKind.FORM;
+    fields: FormFieldConfig<TModel>[];
+    rows?: FormRow<TModel>[];
+    layout?: FormLayoutMode;
+    initialValue?: Partial<TModel>;
+    submitMode?: SubmitMode;
+    onComplete?: ModalResultHandler<TResult>;
+    /** Form-level validators for cross-field validation */
+    formValidators?: FormValidator<TModel>[];
+    /** Angular FormGroup-level validators (e.g., Validators.required on the group) */
+    groupValidators?: any[];
+    /** Field groups with section headers */
+    fieldGroups?: FormFieldGroup<TModel>[];
+}
+interface ConfirmationModalConfig<TResult = boolean> extends BaseModalConfig<TResult> {
+    kind: ModalKind.CONFIRMATION;
+    message: string;
+    tone?: ConfirmationTone;
+    confirm?: ConfirmationActionConfig<TResult>;
+    cancel?: CancellationActionConfig;
+}
+interface CustomModalConfig<TResult = unknown> extends BaseModalConfig<TResult> {
+    kind: ModalKind.CUSTOM;
+    component?: Type<unknown>;
+    template?: TemplateRef<unknown>;
+    inputs?: ModalInputMap;
+    onComplete?: ModalResultHandler<TResult>;
+}
+type ModalConfig<TResult = any> = WizardModalConfig<TResult> | FormModalConfig<any, TResult> | ConfirmationModalConfig<TResult> | CustomModalConfig<TResult>;
+
+declare class StepBuilder<TModel = any> {
+    private config;
+    private currentRow;
+    private currentRowColumns;
+    constructor(id: string, title: string);
+    body(body: any): this;
+    state(state: StepState): this;
+    guard(guard: StepGuard): this;
+    validators(validators: StepValidator[]): this;
+    /**
+     * Add a field to this step. This is the single API for all field types.
+     *
+     * @example
+     * s.field({ kind: FieldKind.TEXT, key: 'email', label: 'Email', validators: [Validators.required] })
+     * s.field({ kind: FieldKind.SELECT, key: 'role', label: 'Role', options: [...] })
+     */
+    field(field: FormFieldConfig<TModel>): this;
+    /**
+     * Start a new row with the specified number of columns.
+     * All subsequent `addToRow()` calls will add fields to this row.
+     */
+    row(columns?: number): this;
+    /**
+     * Add a field to the current row started by `row()`.
+     */
+    addToRow(field: FormFieldConfig<TModel>, span?: number): this;
+    private flushCurrentRow;
+    /**
+     * Add a field group with a section header.
+     */
+    fieldGroup(group: FormFieldGroup<TModel>): this;
+    /**
+     * Add form-level validators for cross-field validation within this step.
+     */
+    formValidators(validators: FormValidator<TModel>[]): this;
+    /**
+     * Add Angular FormGroup-level validators for this step.
+     */
+    groupValidators(validators: any[]): this;
+    /**
+     * Set initial values for fields in this step.
+     */
+    initialValue(value: Partial<TModel>): this;
+    /**
+     * Set a visibility condition for this step based on aggregated wizard data.
+     */
+    visible(condition: (aggregatedData: Record<ModalStepId, Record<string, any>>) => boolean): this;
+    build(): WizardStepConfig<TModel>;
+}
+
+declare abstract class BaseModalBuilder<TConfig extends BaseModalConfig<TResult>, TResult = unknown> {
+    protected config: TConfig;
+    protected constructor(initialConfig: TConfig);
+    title(title: string): this;
+    subtitle(subtitle: string): this;
+    description(description: string): this;
+    closeGuard(guard: () => Promise<boolean> | boolean): this;
+    size(size: ModalSize): this;
+    closeMode(mode: CloseMode): this;
+    backdrop(mode: BackdropMode): this;
+    keyboard(mode: KeyboardMode): this;
+    intent(intent: ModalIntent): this;
+    footerActions(actions: ModalFooterAction<TResult>[]): this;
+    polling(config: ModalPollingConfig<TResult>): this;
+    onCancel(handler: ModalCancelHandler<TResult>): this;
+    i18n(labels: ModalI18nLabels): this;
+    build(): Readonly<TConfig>;
+}
+
+declare class WizardModalBuilder extends BaseModalBuilder<WizardModalConfig, WizardResult> {
+    constructor();
+    step(step: WizardStepConfig | ((builder: StepBuilder) => void)): this;
+    addStep(title: string, buildFn: (builder: StepBuilder) => void, id?: ModalStepId): this;
+    startAt(stepId: ModalStepId): this;
+    flow(mode: WizardFlowMode): this;
+    onStepChange(handler: WizardStepChangeHandler): this;
+    onComplete(handler: ModalResultHandler<WizardResult>): this;
+    onBeforeComplete(validators: WizardBeforeCompleteValidator[]): this;
+}
+
+declare class FormModalBuilder<TModel = unknown, TResult = TModel> extends BaseModalBuilder<FormModalConfig<TModel, TResult>, TResult> {
+    private currentRow;
+    private currentRowColumns;
+    constructor();
+    /**
+     * Add a field as a full-width row (single column).
+     * This is the simple API — each field gets its own row.
+     */
+    field(field: FormFieldConfig<TModel>): this;
+    /**
+     * Start a new row with the specified number of columns.
+     * All subsequent `addToRow()` calls will add fields to this row
+     * until the next `row()` or `field()` call.
+     *
+     * @example
+     * .row(2)
+     *   .addToRow({ kind: FieldKind.TEXT, key: 'firstName', label: 'First Name' })
+     *   .addToRow({ kind: FieldKind.TEXT, key: 'lastName', label: 'Last Name' })
+     * .row(3)
+     *   .addToRow({ kind: FieldKind.TEXT, key: 'city', label: 'City' }, 2)
+     *   .addToRow({ kind: FieldKind.TEXT, key: 'zip', label: 'ZIP' })
+     */
+    row(columns?: number): this;
+    /**
+     * Add a field to the current row started by `row()`.
+     * @param field - The field configuration
+     * @param span - How many columns this field should span (default: 1)
+     */
+    addToRow(field: FormFieldConfig<TModel>, span?: number): this;
+    private flushCurrentRow;
+    layout(mode: FormLayoutMode): this;
+    initialValue(value: Partial<TModel>): this;
+    submitMode(mode: SubmitMode): this;
+    onComplete(handler: ModalResultHandler<TResult>): this;
+    /**
+     * Add form-level validators for cross-field validation.
+     * These receive the entire form value and return an error map or null.
+     */
+    formValidators(validators: FormValidator<TModel>[]): this;
+    /**
+     * Add Angular FormGroup-level validators.
+     * These are standard Angular ValidatorFn applied to the FormGroup itself.
+     */
+    groupValidators(validators: any[]): this;
+    /**
+     * Add a field group with a section header.
+     * Groups visually separate fields with a title and optional description.
+     */
+    fieldGroup(group: FormFieldGroup<TModel>): this;
+    build(): Readonly<FormModalConfig<TModel, TResult>>;
+}
+
+declare class ConfirmationModalBuilder<TResult = boolean> extends BaseModalBuilder<ConfirmationModalConfig<TResult>, TResult> {
+    constructor();
+    message(text: string): this;
+    tone(tone: ConfirmationTone): this;
+    confirmAction(action: ConfirmationActionConfig<TResult>): this;
+    cancelAction(action: CancellationActionConfig): this;
+}
+
+declare class CustomModalBuilder<TResult = unknown> extends BaseModalBuilder<CustomModalConfig<TResult>, TResult> {
+    constructor();
+    component(component: Type<unknown>): this;
+    template(template: TemplateRef<unknown>): this;
+    inputs(inputs: ModalInputMap): this;
+    onComplete(handler: ModalResultHandler<TResult>): this;
+}
+
+declare class ModalBuilder {
+    static wizard(): WizardModalBuilder;
+    static form<TModel = unknown, TResult = TModel>(): FormModalBuilder<TModel, TResult>;
+    static confirmation<TResult = boolean>(): ConfirmationModalBuilder<TResult>;
+    static custom<TResult = unknown>(): CustomModalBuilder<TResult>;
+}
+
+declare class MnModalRef<TResult = any> implements ModalRef<TResult> {
+    private componentRef;
+    private config;
+    private readonly closeSubject;
+    readonly afterClosed$: Observable<ModalCloseEvent<TResult>>;
+    constructor(componentRef: ComponentRef<any>, config: BaseModalConfig<TResult>);
+    close(result?: TResult): void;
+    dismiss(reason: ModalCloseReason): void;
+    private animateAndDestroy;
+    update(config: Partial<BaseModalConfig<TResult>>): void;
+    private destroy;
+}
+
+declare class MnModalService {
+    private readonly appRef;
+    private readonly injector;
+    open<TResult = any>(config: ModalConfig<TResult>): MnModalRef<TResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MnModalService>;
+}
+
+declare class MnModalShellComponent<TResult = any> implements OnInit, AfterViewInit, OnDestroy {
+    private el;
+    config: ModalConfig<TResult>;
+    modalRef: MnModalRef<TResult>;
+    isClosing: boolean;
+    readonly ModalKind: typeof ModalKind;
+    private previouslyFocusedElement;
+    private focusTrapListener;
+    private pollingTimer;
+    private pollAttempts;
+    constructor(el: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setupFocusTrap;
+    private removeFocusTrap;
+    asWizard(config: any): any;
+    asForm(config: any): any;
+    asConfirmation(config: any): any;
+    asCustom(config: any): any;
+    asAny(val: any): any;
+    get hostClasses(): string;
+    startClosing(): Promise<void>;
+    onEscapeKey(event: any): void;
+    onBackdropClick(): void;
+    onCloseButtonClick(): void;
+    private handleClose;
+    get showBackdrop(): boolean;
+    get containerSizeClass(): string;
+    get showCloseButton(): boolean;
+    get hasCustomFooterActions(): boolean;
+    get leftFooterActions(): ModalFooterAction<TResult>[];
+    get rightFooterActions(): ModalFooterAction<TResult>[];
+    onFooterAction(action: ModalFooterAction<TResult>): Promise<void>;
+    getActionButtonColor(style?: ActionStyle): 'primary' | 'secondary' | 'danger' | 'warning' | 'success';
+    getActionButtonVariant(style?: ActionStyle): 'fill' | 'outline' | 'text';
+    private startPollingIfConfigured;
+    private startPolling;
+    private stopPolling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnModalShellComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnModalShellComponent<any>, "mn-modal-shell", never, { "config": { "alias": "config"; "required": false; }; "modalRef": { "alias": "modalRef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnFormBodyComponent<TModel = any, TResult = TModel> implements OnInit, OnDestroy {
+    private fb;
+    config: FormModalConfig<TModel, TResult>;
+    modalRef: MnModalRef<TResult>;
+    hideFooter: boolean;
+    form: FormGroup;
+    rows: FormRow<TModel>[];
+    fieldGroups: FormFieldGroup<TModel>[];
+    isSubmitting: boolean;
+    readonly FieldKind: typeof FieldKind;
+    readonly ModalCloseReason: typeof ModalCloseReason;
+    /** Cross-field validation errors: { fieldKey: errorMessage } */
+    formErrors: Record<string, string>;
+    /** Track which fields are currently visible (for conditional fields) */
+    fieldVisibility: Record<string, boolean>;
+    /** Track loading state per field for async data sources */
+    fieldLoading: Record<string, boolean>;
+    /** Dynamic options loaded from data sources */
+    fieldOptions: Record<string, SelectOption[]>;
+    private valueChangesSubscription?;
+    constructor(fb: FormBuilder);
+    asField(field: any): any;
+    asKey(key: any): string;
+    asAny(val: any): any;
+    hasRequiredValidator(field: any): boolean;
+    /** Store table data sources keyed by field key for template access */
+    tableDataSources: Record<string, any>;
+    /** Resolved i18n labels with defaults */
+    get labels(): {
+        submit: any;
+        cancel: any;
+        submitting: any;
+        selectPlaceholder: any;
+        loading: any;
+        fileUploadPrompt: any;
+    };
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeForm;
+    isFieldReadOnly(field: FormFieldConfig<TModel>): boolean;
+    isFieldDisabled(field: FormFieldConfig<TModel>): boolean;
+    /** Track which field groups are currently visible */
+    groupVisibility: Record<string, boolean>;
+    private buildRows;
+    private initializeGroupVisibility;
+    private updateGroupVisibility;
+    isGroupVisible(group: FormFieldGroup<TModel>): boolean;
+    private initializeVisibility;
+    private updateVisibility;
+    isFieldVisible(field: FormFieldConfig<TModel>): boolean;
+    private runFormValidators;
+    getFieldError(key: string): string | null;
+    get hasFormErrors(): boolean;
+    private initializeDataSources;
+    private loadFieldOptions;
+    /** Get options for a field — uses dataSource options if available, otherwise static options */
+    getFieldOptions(field: FormFieldConfig<TModel>): SelectOption[];
+    isFieldLoading(key: string): boolean;
+    private initializeTableFields;
+    onTableSelectionChange(field: FormFieldConfig<TModel>, selectedRows: any[]): void;
+    getRatingRange(field: FormFieldConfig<TModel>): number[];
+    setRating(field: FormFieldConfig<TModel>, value: number): void;
+    getRatingValue(field: FormFieldConfig<TModel>): number;
+    onSliderChange(field: FormFieldConfig<TModel>, event: Event): void;
+    getSliderValue(field: FormFieldConfig<TModel>): number;
+    onColorChange(field: FormFieldConfig<TModel>, event: Event): void;
+    setColorFromSwatch(field: FormFieldConfig<TModel>, color: string): void;
+    getColorValue(field: FormFieldConfig<TModel>): string;
+    private subscribeToValueChanges;
+    private previousFormValue;
+    private reloadDependentDataSources;
+    getGridColumns(row: FormRow<TModel>): string;
+    getGridSpan(rowField: FormRowField<TModel>): string;
+    /** Store selected files keyed by field key */
+    fileSelections: Record<string, File[]>;
+    onFileChange(field: FormFieldConfig<TModel>, event: Event): void;
+    removeFile(key: string, index: number): void;
+    getSelectedFiles(key: string): File[];
+    formatFileSize(bytes: number): string;
+    getFileError(field: FormFieldConfig<TModel>): string;
+    submit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnFormBodyComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnFormBodyComponent<any, any>, "mn-form-body", never, { "config": { "alias": "config"; "required": false; }; "modalRef": { "alias": "modalRef"; "required": false; }; "hideFooter": { "alias": "hideFooter"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnWizardBodyComponent implements OnInit, AfterViewInit, OnDestroy {
+    private cdr;
+    config: WizardModalConfig;
+    modalRef: MnModalRef<WizardResult>;
+    formBodies: QueryList<MnFormBodyComponent>;
+    currentStepId: ModalStepId;
+    visitedStepIds: ModalStepId[];
+    isCurrentStepValid: boolean;
+    isCompleting: boolean;
+    wizardErrors: Record<string, string>;
+    /** Resolved i18n labels with defaults */
+    get labels(): {
+        next: any;
+        back: any;
+        close: any;
+        complete: any;
+        completing: any;
+    };
+    /** Pre-built form configs keyed by step id — only for steps that have fields */
+    stepFormConfigs: Record<ModalStepId, FormModalConfig<any, any>>;
+    private statusSubscription?;
+    private formBodiesSubscription?;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    asAny(val: any): any;
+    isTextBody(step: WizardStepConfig): boolean;
+    /** Get visible steps (filtered by visibility condition) */
+    get visibleSteps(): WizardStepConfig[];
+    isStepVisible(step: WizardStepConfig): boolean;
+    get currentStep(): WizardStepConfig<any> | undefined;
+    get currentVisibleIndex(): number;
+    get currentStepIndex(): number;
+    get canGoBack(): boolean;
+    get canGoNext(): boolean;
+    get isLastStep(): boolean;
+    get isFreeFlow(): boolean;
+    canNavigateToStep(step: WizardStepConfig): boolean;
+    goToStep(step: WizardStepConfig): Promise<void>;
+    /** Find the MnFormBodyComponent for the current step */
+    private getCurrentFormBody;
+    private trackCurrentStepValidity;
+    next(): Promise<void>;
+    back(): Promise<void>;
+    complete(): Promise<void>;
+    /** Collect form data from all form-driven steps, namespaced by step ID */
+    private getAggregatedData;
+    private notifyStepChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnWizardBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnWizardBodyComponent, "mn-wizard-body", never, { "config": { "alias": "config"; "required": false; }; "modalRef": { "alias": "modalRef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnConfirmationBodyComponent<TResult = boolean> {
+    config: ConfirmationModalConfig<TResult>;
+    modalRef: MnModalRef<TResult>;
+    confirm(): Promise<void>;
+    cancel(): void;
+    get confirmLabel(): string;
+    get cancelLabel(): string;
+    get confirmStyle(): ActionStyle;
+    get cancelStyle(): ActionStyle;
+    get toneClass(): string;
+    getButtonColor(style: ActionStyle): 'primary' | 'secondary' | 'danger' | 'warning' | 'success';
+    getButtonVariant(style: ActionStyle): 'fill' | 'outline' | 'text';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnConfirmationBodyComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnConfirmationBodyComponent<any>, "mn-confirmation-body", never, { "config": { "alias": "config"; "required": false; }; "modalRef": { "alias": "modalRef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnCustomBodyHostComponent implements OnInit {
+    config: CustomModalConfig;
+    modalRef: MnModalRef<unknown>;
+    container: ViewContainerRef;
+    private componentRef?;
+    ngOnInit(): void;
+    private loadContent;
+    attachComponent(component: any): void;
+    attachTemplate(template: TemplateRef<unknown>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnCustomBodyHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnCustomBodyHostComponent, "mn-custom-body-host", never, { "config": { "alias": "config"; "required": false; }; "modalRef": { "alias": "modalRef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnTable<T = any> implements OnInit, OnDestroy {
+    dataSource: TableDataSource<T>;
+    sortChange: EventEmitter<SortState | null>;
+    selectionChange: EventEmitter<T[]>;
+    rowClick: EventEmitter<T>;
+    filteredItems: T[];
+    searchValue: string;
+    loadingMoreRows: boolean;
+    currentSort: SortState | null;
+    selectedIds: Set<string>;
+    private dataSubscription?;
+    private searchSubject;
+    private searchSubscription?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSearch(searchString: string): void;
+    sort(column: ColumnDefinition<T>): void;
+    getSortIcon(column: ColumnDefinition<T>): string;
+    isSortable(column: ColumnDefinition<T>): boolean;
+    isSelected(row: T): boolean;
+    toggleRow(row: T): void;
+    toggleAll(): void;
+    get allSelected(): boolean;
+    get hasSelection(): boolean;
+    get isMultiSelect(): boolean;
+    onRowClick(row: T): void;
+    loadMoreRows(): void;
+    get showLoadMore(): boolean;
+    isTemplateRef(value: any): value is TemplateRef<any>;
+    getCellValue(column: ColumnDefinition<T>, row: T): string;
+    trackByID: (_index: number, row: T) => string;
+    trackByKey: (_index: number, column: ColumnDefinition<T>) => string;
+    get tableClasses(): string;
+    get hasRowActions(): boolean;
+    getVisibleActions(row: T): mn_angular_lib.TableRowAction<T>[];
+    get totalColumnCount(): number;
+    get skeletonRows(): number[];
+    private applyFilterAndSort;
+    private applySorting;
+    private processLoadedRows;
+    private emitSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnTable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MnTable<any>, "mn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; }, never, never, true, never>;
+}
+
+/**
+ * Types for mn-lib configuration.
+ */
+interface MnConfigFile {
+    /**
+     * Base defaults by component name. Each value is a plain object with inputs/options for that component.
+     */
+    defaults: Record<string, unknown>;
+    /**
+     * Nested object tree keyed by section names. Leaf nodes may contain
+     * component-name keys (component override objects) and keys starting with '#'
+     * representing instance-id overrides.
+     */
+    overrides: unknown;
+}
+
+declare class MnConfigService {
+    private readonly http;
+    private _config;
+    private _debugMode;
+    private readonly lang;
+    constructor(http: HttpClient);
+    /**
+     * Load the configuration JSON from the provided URL and cache it in memory.
+     * Consumers should typically call this via the APP_INITIALIZER helper.
+     */
+    load(url: string, debugMode?: boolean): Promise<void>;
+    /**
+     * Resolve a configuration object for a component, optionally scoped to a section path
+     * and optionally overridden by an instance id.
+     */
+    resolve<T extends object = any>(componentName: string, sectionPath?: string[], instanceId?: string): T;
+    /**
+     * Walk the overrides nested object using the provided section path and return the leaf node.
+     * If any segment is missing or the current node is not a plain object, returns undefined.
+     */
+    walkOverrides(overridesRoot: unknown, sectionPath: string[]): unknown | undefined;
+    /**
+     * Recursively walk a resolved config object and replace any `{ $translate: "key" }` markers
+     * with their translated values from MnLanguageService.
+     */
+    private resolveTranslatables;
+    /**
+     * Deep merge two plain-object trees. Arrays and non-plain values are replaced by the patch.
+     * Does not mutate inputs; returns a new object.
+     */
+    deepMerge<A extends Record<string, any>, B extends Record<string, any>>(base: A, patch: B): A & B;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MnConfigService>;
+}
+
+/**
+ * Provides an APP_INITIALIZER that loads the mn-lib configuration from the given URL
+ * during application bootstrap. The consuming application is responsible for providing
+ * HttpClient (e.g., via HttpClientModule or provideHttpClient()).
+ */
+declare function provideMnConfig(url: string, debugMode?: boolean): Provider[];
+
+/**
+ * Helper to provide a resolved, typed component config via DI.
+ *
+ * Usage in a component/module providers:
+ *   const MY_CFG = new InjectionToken<MyCfg>('MY_CFG');
+ *   providers: [ provideMnComponentConfig(MY_CFG, 'my-component') ]
+ * Then in the component:
+ *   readonly cfg = inject(MY_CFG)
+ */
+declare function provideMnComponentConfig<T extends object>(token: InjectionToken<T>, componentName: string, initial?: Partial<T>): Provider;
+
+/**
+ * Represents the current section path based on nested mn-section directives.
+ */
+declare const MN_SECTION_PATH: InjectionToken<string[]>;
+/**
+ * Represents the current component instance id provided by [mn-instance].
+ */
+declare const MN_INSTANCE_ID: InjectionToken<string | null>;
+
+declare class MnSectionDirective {
+    /** Section name contributed by this DOM node to the section path */
+    mnSection: string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnSectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MnSectionDirective, "[mn-section]", never, { "mnSection": { "alias": "mn-section"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MnInstanceDirective {
+    /** Instance id for targeting per-component instance overrides */
+    mnInstance: string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnInstanceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MnInstanceDirective, "[mn-instance]", never, { "mnInstance": { "alias": "mn-instance"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A structured representation of an API error.
+ *
+ * Captures all relevant details — status, message, validation errors,
+ * and retry information — so consumers can log, display, or act on
+ * failures without inspecting the raw HTTP response.
+ */
+interface ApiError {
+    status: HttpStatusCode | null;
+    message: string;
+    details?: unknown;
+    backendMessage?: string;
+    validationErrors?: Record<string, string[]>;
+    url?: string | null;
+    headers?: HttpHeaders;
+    original: HttpErrorResponse | Error;
+    retryable: boolean;
+    timestamp: string;
+}
+/**
+ * Metadata associated with an API result.
+ *
+ * Attached to both `SuccessResult` and `FailureResult` to provide
+ * transport-level details such as the HTTP status code, response
+ * headers, and the final URL after any redirects.
+ */
+interface ResultMeta {
+    statusCode?: number;
+    headers?: HttpHeaders;
+    url?: string;
+}
+/**
+ * Represents a successful API result containing the response data.
+ *
+ * Discriminated by `ok: true`. Use `result.ok` to narrow the union
+ * before accessing `data`.
+ *
+ * @template T The type of the response data.
+ */
+interface SuccessResult<T> {
+    ok: true;
+    data: T;
+    meta?: ResultMeta;
+}
+/**
+ * Represents a failed API result containing the structured error.
+ *
+ * Discriminated by `ok: false`. Use `result.ok` to narrow the union
+ * before accessing `error`.
+ */
+interface FailureResult {
+    ok: false;
+    error: ApiError;
+    meta?: ResultMeta;
+}
+/**
+ * A discriminated union representing either a successful or failed API result.
+ *
+ * Discriminated by `ok`. Use `result.ok` to narrow the type
+ * before accessing `data` or `error`.
+ *
+ * @template T The type of the response data on success.
+ */
+type Result<T> = SuccessResult<T> | FailureResult;
+/**
+ * A JavaScript primitive value.
+ *
+ * Used as the building block for query parameter values.
+ */
+type Primitive = string | number | boolean | null | undefined;
+/**
+ * A value that can be used as a query parameter.
+ *
+ * Either a single primitive or an array of primitives.
+ * Array values are appended as multiple entries for the same key.
+ */
+type QueryValue = Primitive | Primitive[];
+/**
+ * A record of query parameter key-value pairs.
+ *
+ * Passed to CRUD service methods and converted to `HttpParams`
+ * before the request is sent. `null` and `undefined` values
+ * are silently skipped during conversion.
+ */
+type QueryParams = Record<string, QueryValue>;
+
+/**
+ * Configuration for a CRUD service endpoint.
+ *
+ * Passed to the `CrudService` constructor to define which API
+ * resource the service operates on.
+ */
+interface CrudConfig {
+    endpoint: string;
+}
+/**
+ * Abstract base class for CRUD services.
+ * Provides standard HTTP operations with typed `Result<T>` responses.
+ *
+ * @template TEntity The entity type returned by single-item operations.
+ * @template TListResponse The response type for list operations (defaults to `TEntity[]`).
+ * @template TCreatePayload The payload type for create operations (defaults to `Partial<TEntity>`).
+ * @template TUpdatePayload The payload type for update operations (defaults to `Partial<TEntity>`).
+ * @template TId The type of the entity identifier (defaults to `number`).
+ * @template TGetByIdResponse The response type for getById (defaults to `TEntity`).
+ * @template TCreateResponse The response type for create (defaults to `TEntity`).
+ * @template TUpdateResponse The response type for update and patch (defaults to `TEntity`).
+ * @template TDeleteResponse The response type for delete (defaults to `void`).
+ */
+declare abstract class CrudService<TEntity, TListResponse = TEntity[], TCreatePayload = Partial<TEntity>, TUpdatePayload = Partial<TEntity>, TId extends string | number = number, TGetByIdResponse = TEntity, TCreateResponse = TEntity, TUpdateResponse = TEntity, TDeleteResponse = void> {
+    protected readonly http: HttpClient;
+    protected readonly baseUrl: string;
+    protected readonly endpoint: string;
+    protected constructor(config: CrudConfig);
+    /**
+     * Retrieves all entities from the configured endpoint.
+     *
+     * Sends a GET request to the base endpoint. Query values are
+     * converted to `HttpParams` before the request is sent.
+     *
+     * @param query Optional query parameters appended to the request URL.
+     * @returns An observable emitting a `Result` with the list response or a structured failure.
+     */
+    getAll(query?: QueryParams): Observable<Result<TListResponse>>;
+    /**
+     * Retrieves a single entity by its identifier.
+     *
+     * Sends a GET request to `{endpoint}/{id}`.
+     *
+     * @param id The unique identifier of the entity to retrieve.
+     * @returns An observable emitting a `Result` with the entity or a structured failure.
+     */
+    getById(id: TId): Observable<Result<TGetByIdResponse>>;
+    /**
+     * Creates a new entity at the configured endpoint.
+     *
+     * Sends a POST request with the provided payload as the request body.
+     *
+     * @param payload The data used to create the entity.
+     * @returns An observable emitting a `Result` with the created entity or a structured failure.
+     */
+    create(payload: TCreatePayload): Observable<Result<TCreateResponse>>;
+    /**
+     * Fully replaces an existing entity.
+     *
+     * Sends a PUT request to `{endpoint}/{id}` with the provided payload,
+     * replacing the entire entity.
+     *
+     * @param id The unique identifier of the entity to update.
+     * @param payload The complete data to replace the existing entity with.
+     * @returns An observable emitting a `Result` with the updated entity or a structured failure.
+     */
+    update(id: TId, payload: TUpdatePayload): Observable<Result<TUpdateResponse>>;
+    /**
+     * Partially updates an existing entity.
+     *
+     * Sends a PATCH request to `{endpoint}/{id}` with the provided payload,
+     * merging changes into the existing entity.
+     *
+     * @param id The unique identifier of the entity to patch.
+     * @param payload A partial set of fields to update on the existing entity.
+     * @returns An observable emitting a `Result` with the updated entity or a structured failure.
+     */
+    patch(id: TId, payload: Partial<TUpdatePayload>): Observable<Result<TUpdateResponse>>;
+    /**
+     * Deletes an entity by its identifier.
+     *
+     * Sends a DELETE request to `{endpoint}/{id}`.
+     *
+     * @param id The unique identifier of the entity to delete.
+     * @returns An observable emitting a `Result` with the delete response or a structured failure.
+     */
+    delete(id: TId): Observable<Result<TDeleteResponse>>;
+    /**
+     * Retrieves all entities with the full `HttpResponse` wrapper.
+     *
+     * Behaves like {@link getAll} but observes the complete HTTP response,
+     * giving access to headers, status code, and URL alongside the body.
+     *
+     * @param query Optional query parameters appended to the request URL.
+     * @returns An observable emitting a `Result` with the full HTTP response or a structured failure.
+     */
+    getAllResponse(query?: QueryParams): Observable<Result<HttpResponse<TListResponse>>>;
+    /**
+     * Builds the URL for a single entity by appending the identifier to the endpoint.
+     *
+     * @param id The unique identifier to append.
+     * @returns The full URL targeting the specific entity.
+     */
+    protected itemUrl(id: TId): string;
+    /**
+     * Wraps a value in a `SuccessResult`.
+     *
+     * @template T The type of the response data.
+     * @param data The response data to wrap.
+     * @param meta Optional metadata (status code, headers, URL) to attach.
+     * @returns A `SuccessResult` containing the provided data.
+     */
+    protected success<T>(data: T, meta?: ResultMeta): SuccessResult<T>;
+    /**
+     * Wraps an error in a `FailureResult`.
+     *
+     * When no explicit metadata is provided, metadata is derived from
+     * the `ApiError` itself (status code, headers, URL).
+     *
+     * @param error The structured API error.
+     * @param meta Optional metadata to override the error-derived values.
+     * @returns A `FailureResult` containing the error and metadata.
+     */
+    protected failure(error: ApiError, meta?: ResultMeta): FailureResult;
+    /**
+     * Maps an unknown error into a structured `ApiError`.
+     *
+     * Handles both `HttpErrorResponse` instances and unexpected error types.
+     * Extracts backend messages, validation errors, and retry information
+     * so callers receive a consistent error shape.
+     *
+     * @param error The raw error caught from the HTTP pipeline.
+     * @returns A fully populated `ApiError` object.
+     */
+    protected mapHttpError(error: unknown): ApiError;
+    /**
+     * Extracts a human-readable message from the error response body.
+     *
+     * Checks common keys (`message`, `title`, `detail`, `error`) on the
+     * body object and returns the first non-empty string found.
+     *
+     * @param body The parsed error response body.
+     * @returns The extracted message, or `undefined` if none was found.
+     */
+    protected extractBackendMessage(body: unknown): string | undefined;
+    /**
+     * Extracts field-level validation errors from the error response body.
+     *
+     * Expects an `errors` property on the body containing a record of
+     * field names to error messages (string or string array).
+     *
+     * @param body The parsed error response body.
+     * @returns A record mapping field names to their error messages, or `undefined` if none were found.
+     */
+    protected extractValidationErrors(body: unknown): Record<string, string[]> | undefined;
+    /**
+     * Returns a default user-facing message for the given HTTP status code.
+     *
+     * Provides human-readable messages for common HTTP status codes.
+     * Override this method to customise messages.
+     *
+     * @param status The HTTP status code, or `null` when unknown.
+     * @returns A descriptive error message.
+     */
+    protected defaultMessage(status: HttpStatusCode | null): string;
+    /**
+     * Determines whether a request with the given status can be retried.
+     *
+     * Timeouts, rate-limiting responses, and server errors
+     * (5xx) are considered retryable by default.
+     *
+     * @param status The HTTP status code, or `null` when unknown.
+     * @returns `true` if the request is safe to retry.
+     */
+    protected isRetryable(status: HttpStatusCode | null): boolean;
+    /**
+     * Normalises a raw HTTP status into an `HttpStatusCode | null` value.
+     *
+     * Converts `undefined`, `NaN`, and `0` (network error) to `null`
+     * so downstream code only needs to handle `HttpStatusCode | null`.
+     *
+     * @param status The raw status value from the HTTP response.
+     * @returns The normalised status code, or `null` when indeterminate.
+     */
+    protected normalizeStatus(status: number | null | undefined): HttpStatusCode | null;
+    /**
+     * Converts query parameters into Angular `HttpParams`.
+     *
+     * `null` and `undefined` values are silently skipped.
+     * Array values are appended as multiple entries for the same key.
+     *
+     * @param query The query parameter record to convert.
+     * @returns An `HttpParams` instance, or `undefined` when no parameters are provided.
+     */
+    protected toHttpParams(query?: QueryParams): HttpParams | undefined;
+}
+
+/**
+ * Injection token for the base URL used by all CRUD service requests.
+ *
+ * Provide this token at the application or module level to configure
+ * the root API URL that `CrudService` prepends to every endpoint.
+ */
+declare const API_BASE_URL: InjectionToken<string>;
+
+/**
+ * A marker object used in config values to indicate that the value
+ * should be resolved via the MnLanguageService.
+ *
+ * Example in mn-config.json5:
+ *   label: { $translate: "form.email.label" }
+ */
+interface MnTranslatable {
+    $translate: string;
+    params?: Record<string, string | number>;
+}
+/**
+ * A config value that is either a plain value or a translatable marker.
+ */
+type MnConfigValue<T = string> = T | MnTranslatable;
+/**
+ * A flat key-value map of translations for a single locale.
+ * Supports nested keys via dot notation: "form.email.label"
+ */
+type MnTranslationMap = Record<string, string>;
+/**
+ * All loaded translations keyed by locale code (e.g. "en", "nl", "de").
+ */
+type MnTranslations = Record<string, MnTranslationMap>;
+/**
+ * Configuration for the language provider.
+ */
+interface MnLanguageConfig {
+    /** URL pattern for loading translation files. Use `{locale}` as placeholder. e.g. "assets/i18n/{locale}.json" */
+    urlPattern: string;
+    /** The default/fallback locale. */
+    defaultLocale: string;
+    /** Locales to preload at bootstrap. */
+    preload?: string[];
+}
+/**
+ * Type guard: checks whether a value is a translatable marker object.
+ */
+declare function isTranslatable(value: unknown): value is MnTranslatable;
+
+declare class MnLanguageService {
+    private readonly http;
+    private _translations;
+    private _locale$;
+    private _urlPattern;
+    /** Observable of the current active locale. */
+    readonly locale$: Observable<string>;
+    constructor(http: HttpClient);
+    /** Current active locale. */
+    get locale(): string;
+    /**
+     * Configure the URL pattern used to fetch translation files.
+     * Use `{locale}` as placeholder, e.g. `"assets/i18n/{locale}.json"`.
+     */
+    configure(urlPattern: string): void;
+    /**
+     * Load translations for a locale from the configured URL pattern.
+     * If translations are already loaded for this locale, this is a no-op.
+     */
+    loadLocale(locale: string): Promise<void>;
+    /**
+     * Switch the active locale. Loads translations if not yet loaded.
+     */
+    setLocale(locale: string): Promise<void>;
+    /**
+     * Register translations for a locale directly from code (no HTTP needed).
+     */
+    registerTranslations(locale: string, translations: MnTranslationMap): void;
+    /**
+     * Translate a key using the current locale, with optional parameter interpolation.
+     * Falls back to the key itself if no translation is found.
+     *
+     * Interpolation replaces `{{paramName}}` with the provided value.
+     */
+    translate(key: string, params?: Record<string, string | number>): string;
+    /**
+     * Shorthand alias for `translate`.
+     */
+    t(key: string, params?: Record<string, string | number>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MnLanguageService>;
+}
+
+/**
+ * Provides an APP_INITIALIZER that configures the MnLanguageService and
+ * preloads the requested locales during application bootstrap.
+ *
+ * Usage in app.config.ts:
+ *   ...provideMnLanguage({
+ *     urlPattern: 'assets/i18n/{locale}.json',
+ *     defaultLocale: 'en',
+ *     preload: ['en', 'nl'],
+ *   })
+ */
+declare function provideMnLanguage(config: MnLanguageConfig): Provider[];
+
+/**
+ * Pipe that translates a key via MnLanguageService.
+ *
+ * Usage in templates:
+ *   {{ 'form.email.label' | mnTranslate }}
+ *   {{ 'greeting' | mnTranslate:{ name: 'World' } }}
+ *
+ * Note: This pipe is impure so it re-evaluates when the locale changes.
+ */
+declare class MnTranslatePipe implements PipeTransform {
+    private readonly lang;
+    constructor(lang: MnLanguageService);
+    transform(key: string, params?: Record<string, string | number>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MnTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MnTranslatePipe, "mnTranslate", true>;
 }
 
-export { DEFAULT_MN_ALERT_CONFIG, MN_ALERT_CONFIG, MN_INPUT_FIELD_CONFIG, MN_INSTANCE_ID, MN_LIB_DUAL_HORIZONTAL_IMAGE, MN_SECTION_PATH, MN_TEST_COMPONENT_CONFIG, MN_TEXTAREA_CONFIG, MnAlertOutletComponent, MnAlertService, MnAlertStore, MnButton, MnConfigService, MnDualHorizontalImage, MnInformationCard, MnInputField, MnInstanceDirective, MnSectionDirective, MnTestComponent, MnTextarea, Test, dateTimeAdapter, defaultTextAdapter, mnAlertVariants, mnButtonVariants, mnInformationCardVariants, mnInputFieldVariants, mnTextareaVariants, numberAdapter, pickAdapter, provideMnAlerts, provideMnComponentConfig, provideMnConfig };
-export type { MnAlert, MnAlertConfig, MnAlertId, MnAlertKind, MnAlertTemplateContext, MnAlertVariants, MnButtonTypes, MnButtonVariants, MnConfigFile, MnDomAttrs, MnDualHorizontalImageConfig, MnDualHorizontalImageTypes, MnErrorMessageData, MnErrorMessagesData, MnImageType, MnInformationCardBaseData, MnInformationCardData, MnInformationCardVariants, MnInputAdapter, MnInputBaseProps, MnInputDateTimeProps, MnInputFieldProps, MnInputFieldUIConfig, MnInputProps, MnInputType, MnInputVariants, MnShowInput, MnTextareaErrorMessageData, MnTextareaErrorMessagesData, MnTextareaProps, MnTextareaUIConfig, MnTextareaVariants };
+export { API_BASE_URL, ActionStyle, BackdropMode, BaseModalBuilder, CloseMode, ColumnSortType, ConfirmationModalBuilder, ConfirmationTone, CrudService, CustomModalBuilder, DEFAULT_MN_ALERT_CONFIG, FieldAppearance, FieldKind, FormLayoutMode, FormModalBuilder, KeyboardMode, MN_ALERT_CONFIG, MN_CHECKBOX_CONFIG, MN_DATETIME_CONFIG, MN_INPUT_FIELD_CONFIG, MN_INSTANCE_ID, MN_LIB_DUAL_HORIZONTAL_IMAGE, MN_MULTI_SELECT_CONFIG, MN_SECTION_PATH, MN_TEST_COMPONENT_CONFIG, MN_TEXTAREA_CONFIG, MnAlertOutletComponent, MnAlertService, MnAlertStore, MnButton, MnCheckbox, MnConfigService, MnConfirmationBodyComponent, MnCustomBodyHostComponent, MnDatetime, MnDualHorizontalImage, MnFormBodyComponent, MnInformationCard, MnInputField, MnInstanceDirective, MnLanguageService, MnModalRef, MnModalService, MnModalShellComponent, MnMultiSelect, MnSectionDirective, MnTable, MnTestComponent, MnTextarea, MnTranslatePipe, MnWizardBodyComponent, ModalBuilder, ModalCloseReason, ModalIntent, ModalKind, ModalSize, NavigationDirection, OptionState, SelectionMode, StepBuilder, StepState, SubmitMode, Test, ValidationCode, ValidationStatus, WizardFlowMode, WizardModalBuilder, dateTimeAdapter, defaultTextAdapter, isTranslatable, mnAlertVariants, mnButtonVariants, mnCheckboxVariants, mnDatetimeVariants, mnInformationCardVariants, mnInputFieldVariants, mnMultiSelectVariants, mnTextareaVariants, numberAdapter, pickAdapter, provideMnAlerts, provideMnComponentConfig, provideMnConfig, provideMnLanguage };
+export type { ApiError, BaseModalConfig, CancellationActionConfig, CheckboxFieldConfig, ColorFieldConfig, ColumnDefinition, ConfirmationActionConfig, ConfirmationModalConfig, CrudConfig, CursorPaginationStrategy, CustomFieldConfig, CustomModalConfig, DateFieldConfig, DatetimeFieldConfig, FailureResult, FieldDataSource, FieldValidator, FieldVisibilityCondition, FileFieldConfig, FormFieldConfig, FormFieldGroup, FormModalConfig, FormRow, FormRowField, FormValidator, MnAlert, MnAlertConfig, MnAlertId, MnAlertKind, MnAlertTemplateContext, MnAlertVariants, MnButtonTypes, MnButtonVariants, MnCheckboxErrorMessageData, MnCheckboxErrorMessagesData, MnCheckboxProps, MnCheckboxUIConfig, MnCheckboxVariants, MnConfigFile, MnConfigValue, MnDatetimeErrorMessageData, MnDatetimeErrorMessagesData, MnDatetimeMode, MnDatetimeProps, MnDatetimeUIConfig, MnDatetimeVariants, MnDomAttrs, MnDualHorizontalImageConfig, MnDualHorizontalImageTypes, MnErrorMessageData, MnErrorMessagesData, MnImageType, MnInformationCardBaseData, MnInformationCardData, MnInformationCardVariants, MnInputAdapter, MnInputBaseProps, MnInputDateTimeProps, MnInputFieldProps, MnInputFieldUIConfig, MnInputProps, MnInputType, MnInputVariants, MnLanguageConfig, MnMultiSelectErrorMessageData, MnMultiSelectErrorMessagesData, MnMultiSelectOption, MnMultiSelectProps, MnMultiSelectUIConfig, MnMultiSelectVariants, MnShowInput, MnTextareaErrorMessageData, MnTextareaErrorMessagesData, MnTextareaProps, MnTextareaUIConfig, MnTextareaVariants, MnTranslatable, MnTranslationMap, MnTranslations, ModalCancelHandler, ModalCloseEvent, ModalConfig, ModalFooterAction, ModalI18nLabels, ModalInputMap, ModalPollingConfig, ModalRef, ModalResultHandler, ModalStepId, MultiSelectFieldConfig, MultiSelectTableFieldConfig, NumberFieldConfig, OffsetPaginationStrategy, PaginationStrategy, PasswordFieldConfig, Primitive, QueryParams, QueryValue, RatingFieldConfig, Result, ResultMeta, SelectFieldConfig, SelectOption, SingleSelectTableFieldConfig, SliderFieldConfig, SortState, StepBodyConfig, StepGuard, StepValidator, SuccessResult, TableAppearance, TableDataSource, TableRowAction, TextFieldConfig, TextareaFieldConfig, ValidationResult, WizardBeforeCompleteValidator, WizardModalConfig, WizardResult, WizardStepChangeEvent, WizardStepChangeHandler, WizardStepConfig };