@mk-kit/ui 0.36.0 → 0.38.0

package/types/mk-kit-ui-core.d.ts

@@ -933,6 +933,93 @@ interface MkI18nStrings {
     logCopyAll: string;
     /** Log viewer: soft-wrap toolbar toggle. */
     logWrapLines: string;
+    /** Chat: accessible name of the message log. */
+    chatLabel: string;
+    /** Chat: accessible name of the composer textarea. */
+    chatComposerLabel: string;
+    /** Chat: composer placeholder. */
+    chatPlaceholder: string;
+    /** Chat: send button. */
+    chatSend: string;
+    /** Chat: stop-generating button (replaces send while busy). */
+    chatStop: string;
+    /** Chat: attach-files button. */
+    chatAttach: string;
+    /** Chat: remove one pending attachment. */
+    chatRemoveAttachment: string;
+    /** Chat: group label of pending / shown attachments. */
+    chatAttachments: string;
+    /** Chat: group label of quick-reply suggestions. */
+    chatSuggestions: string;
+    /** Chat: copy-message button. */
+    chatCopy: string;
+    /** Chat: retry a failed message. */
+    chatRetry: string;
+    /** Chat: typing indicator. */
+    chatTyping: string;
+    /** Chat: screen-reader text while a reply streams in. */
+    chatStreaming: string;
+    /** Chat: scroll-to-newest button. */
+    chatJumpToLatest: string;
+    /** Chat: empty-state text. */
+    chatEmpty: string;
+    /** Chat: author fallback for the user's own messages. */
+    chatYou: string;
+    /** Chat: author fallback for assistant messages. */
+    chatAssistant: string;
+    /** Chat: tool call in progress. */
+    chatToolRunning: string;
+    /** Chat: tool call finished. */
+    chatToolDone: string;
+    /** Chat: tool call failed. */
+    chatToolError: string;
+    /** Dynamic form: add an item to an array field. */
+    dynamicFormAdd: string;
+    /** Dynamic form: remove one item of an array field (index is 1-based). */
+    dynamicFormRemove: (index: number) => string;
+    /** Query builder: accessible name of the whole builder. */
+    queryBuilderLabel: string;
+    queryAddRule: string;
+    queryAddGroup: string;
+    queryRemoveRule: string;
+    queryRemoveGroup: string;
+    /** Combinator labels — also used by `mkQueryToText`. */
+    queryAnd: string;
+    queryOr: string;
+    queryNot: string;
+    queryField: string;
+    queryOperator: string;
+    queryValue: string;
+    queryValueFrom: string;
+    queryValueTo: string;
+    queryEmptyGroup: string;
+    queryTrue: string;
+    queryFalse: string;
+    queryOpEq: string;
+    queryOpNeq: string;
+    queryOpContains: string;
+    queryOpNotContains: string;
+    queryOpStartsWith: string;
+    queryOpEndsWith: string;
+    queryOpGt: string;
+    queryOpGte: string;
+    queryOpLt: string;
+    queryOpLte: string;
+    queryOpBetween: string;
+    queryOpIn: string;
+    queryOpNotIn: string;
+    queryOpBefore: string;
+    queryOpAfter: string;
+    queryOpEmpty: string;
+    queryOpNotEmpty: string;
+    /** Dialog: label of the move grip (arrow keys move, Home resets). */
+    dialogMove: string;
+    /** Dialog: label of the resize grip (arrow keys resize, Home resets). */
+    dialogResize: string;
+    /** Listbox: filter box placeholder / label. */
+    listboxFilter: string;
+    /** Listbox: shown when the filter matches nothing. */
+    listboxEmpty: string;
     /** Announced when an event is picked up in keyboard move mode. */
     eventCalendarGrabbed: (title: string, from: string, to: string) => string;
     /** Announced after each keyboard step: current day + time range. */
@@ -1181,5 +1268,83 @@ type MkErrorMessages = Readonly<Record<string, string | ((err: any) => string)>>
  */
 declare function mkFirstErrorMessage(errors: ValidationErrors | null | undefined, strings: MkValidationStrings, overrides?: MkErrorMessages): string | null;
 
-export { MK_BREAKPOINTS, MK_DEFAULT_BREAKPOINTS, MK_DEFAULT_DATE_NAMES, MK_DEFAULT_I18N, MK_DEFAULT_VALIDATION, MK_I18N, MK_OVERLAY_DATA, MkAnchoredPanel, MkBreakpointService, MkFieldContext, MkFocusTrap, MkLiveAnnouncer, MkOverlayRef, MkOverlayService, MkThemeService, mkComputeAnchoredPosition, mkFirstErrorMessage, mkGetFocusable, mkHighlight, mkHighlightJson, mkIsResponsive, mkUniqueId, mkValidatorChange, provideMkI18n };
-export type { MkAnchoredPosition, MkAnchoredPositionOptions, MkAriaLivePoliteness, MkBlockEditorStrings, MkBreakpoint, MkBreakpoints, MkCodeLanguage, MkDateNames, MkDensity, MkErrorMessages, MkI18nStrings, MkOverlayConfig, MkPlacement, MkResolvedTheme, MkResponsive, MkSize$1 as MkSize, MkSortAnnounceDirection, MkThemePreference, MkTone, MkValidationStrings, MkValidatorChangeRef, MkVariant };
+/** Value kind of a filterable field; decides the editor and the operators offered. */
+type MkQueryValueType = 'string' | 'number' | 'boolean' | 'date' | 'select';
+/** A choice for `select` fields. */
+interface MkQueryFieldOption {
+    label: string;
+    value: unknown;
+}
+/** A field the user can filter on. */
+interface MkQueryField {
+    /** Property key on the row objects / the API's filter name. */
+    key: string;
+    /** Label shown in the field picker. */
+    label: string;
+    /** Default `string`. */
+    type?: MkQueryValueType;
+    /** Choices for `select` fields. */
+    options?: readonly MkQueryFieldOption[];
+    /** Restrict / reorder the operators offered (default: all for the type). */
+    operators?: readonly MkQueryOperator[];
+    /** Placeholder of the value editor. */
+    placeholder?: string;
+}
+/** Comparison operators. Which apply depends on the field type. */
+type MkQueryOperator = 'eq' | 'neq' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'in' | 'notIn' | 'before' | 'after' | 'empty' | 'notEmpty';
+/** A leaf condition. `value` is `[from, to]` for `between`, an array for `in` / `notIn`, absent for `empty` / `notEmpty`. Dates are ISO strings. */
+interface MkQueryRule {
+    id: string;
+    field: string;
+    operator: MkQueryOperator;
+    value?: unknown;
+}
+type MkQueryCombinator = 'and' | 'or';
+/** A group of rules and nested groups joined by one combinator, optionally negated. */
+interface MkQueryGroup {
+    id: string;
+    combinator: MkQueryCombinator;
+    /** Negate the whole group. */
+    not?: boolean;
+    rules: MkQueryNode[];
+}
+type MkQueryNode = MkQueryRule | MkQueryGroup;
+
+/** Operators offered per field type, in menu order. */
+declare const MK_QUERY_OPERATORS: Readonly<Record<MkQueryValueType, readonly MkQueryOperator[]>>;
+/** Operators that take no value. */
+declare const MK_QUERY_UNARY: ReadonlySet<MkQueryOperator>;
+/** True for a group node (as opposed to a rule). */
+declare function mkIsQueryGroup(node: MkQueryNode): node is MkQueryGroup;
+/** A fresh empty group. */
+declare function mkCreateQueryGroup(init?: Partial<Omit<MkQueryGroup, 'id'>>): MkQueryGroup;
+/** A fresh rule on `field`, using its first operator. */
+declare function mkCreateQueryRule(field: MkQueryField): MkQueryRule;
+/** Operators a field offers (its own list, else the defaults for its type). */
+declare function mkQueryOperatorsFor(field: MkQueryField | undefined): readonly MkQueryOperator[];
+/** True when the tree holds no rule at all (empty groups only). */
+declare function mkQueryIsEmpty(group: MkQueryGroup): boolean;
+/** Number of rules in the tree. */
+declare function mkQueryRuleCount(group: MkQueryGroup): number;
+/** Drop empty groups and rules that still need a value, so the API gets only complete conditions. */
+declare function mkQueryCompact(group: MkQueryGroup): MkQueryGroup;
+/** A rule is complete when its operator needs no value or has one. */
+declare function mkQueryRuleIsComplete(rule: MkQueryRule): boolean;
+/** Evaluate one rule against a row. */
+declare function mkQueryRuleMatches(rule: MkQueryRule, row: Record<string, unknown>, field?: MkQueryField): boolean;
+/**
+ * Compile a query into a row predicate for client-side filtering
+ * (`rows.filter(mkQueryToPredicate(query, fields))`). Unfinished rules are
+ * ignored, so a half-edited query never blanks the table.
+ */
+declare function mkQueryToPredicate<T extends object = Record<string, unknown>>(group: MkQueryGroup, fields?: readonly MkQueryField[]): (row: T) => boolean;
+/** Localised label of an operator. */
+declare function mkQueryOperatorLabel(op: MkQueryOperator, i18n?: MkI18nStrings): string;
+/**
+ * Human-readable sentence for a query, e.g.
+ * `(Name contains "ada" and Orders at least 10) or Status is any of Active, Invited`.
+ */
+declare function mkQueryToText(group: MkQueryGroup, fields?: readonly MkQueryField[], i18n?: MkI18nStrings): string;
+
+export { MK_BREAKPOINTS, MK_DEFAULT_BREAKPOINTS, MK_DEFAULT_DATE_NAMES, MK_DEFAULT_I18N, MK_DEFAULT_VALIDATION, MK_I18N, MK_OVERLAY_DATA, MK_QUERY_OPERATORS, MK_QUERY_UNARY, MkAnchoredPanel, MkBreakpointService, MkFieldContext, MkFocusTrap, MkLiveAnnouncer, MkOverlayRef, MkOverlayService, MkThemeService, mkComputeAnchoredPosition, mkCreateQueryGroup, mkCreateQueryRule, mkFirstErrorMessage, mkGetFocusable, mkHighlight, mkHighlightJson, mkIsQueryGroup, mkIsResponsive, mkQueryCompact, mkQueryIsEmpty, mkQueryOperatorLabel, mkQueryOperatorsFor, mkQueryRuleCount, mkQueryRuleIsComplete, mkQueryRuleMatches, mkQueryToPredicate, mkQueryToText, mkUniqueId, mkValidatorChange, provideMkI18n };
+export type { MkAnchoredPosition, MkAnchoredPositionOptions, MkAriaLivePoliteness, MkBlockEditorStrings, MkBreakpoint, MkBreakpoints, MkCodeLanguage, MkDateNames, MkDensity, MkErrorMessages, MkI18nStrings, MkOverlayConfig, MkPlacement, MkQueryCombinator, MkQueryField, MkQueryFieldOption, MkQueryGroup, MkQueryNode, MkQueryOperator, MkQueryRule, MkQueryValueType, MkResolvedTheme, MkResponsive, MkSize$1 as MkSize, MkSortAnnounceDirection, MkThemePreference, MkTone, MkValidationStrings, MkValidatorChangeRef, MkVariant };

package/types/mk-kit-ui-dynamic-form.d.ts

@@ -0,0 +1,305 @@
+import { ValidatorFn, AbstractControl, FormGroup, FormControl, FormArray } from '@angular/forms';
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+/**
+ * Field kinds `mk-dynamic-form` renders out of the box. Each maps to one
+ * mk-kit control; `custom` renders a projected `mkDynamicField` template.
+ */
+type MkDynamicFieldType = 'text' | 'email' | 'password' | 'url' | 'tel' | 'search' | 'textarea' | 'number' | 'currency' | 'date' | 'time' | 'datetime' | 'select' | 'multi-select' | 'autocomplete' | 'radio' | 'toggle' | 'checkbox' | 'switch' | 'slider' | 'rating' | 'color' | 'tags' | 'phone' | 'file' | 'code' | 'custom';
+/** One option of a select / radio / toggle / autocomplete field. */
+interface MkDynamicOption {
+    label: string;
+    value: unknown;
+    disabled?: boolean;
+}
+/**
+ * Declarative validators — plain data so a schema can be stored as JSON.
+ * `custom` takes Angular validator functions for anything else.
+ */
+interface MkDynamicValidators {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    /** A RegExp or its source string. */
+    pattern?: string | RegExp;
+    email?: boolean;
+    /** Angular validator functions appended after the declarative ones. */
+    custom?: ValidatorFn[];
+}
+/**
+ * A serialisable condition over the form value (dotted paths reach into
+ * groups: `address.country`). Combine with `and` / `or`; a function is the
+ * escape hatch for TypeScript-only schemas.
+ */
+type MkDynamicCondition = {
+    field: string;
+    eq?: unknown;
+    neq?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
+    truthy?: boolean;
+    empty?: boolean;
+} | {
+    and: MkDynamicCondition[];
+} | {
+    or: MkDynamicCondition[];
+} | {
+    not: MkDynamicCondition;
+} | ((value: Record<string, unknown>) => boolean);
+/** Properties shared by every field that holds a value. */
+interface MkDynamicFieldBase {
+    /** Key in the form value. */
+    key: string;
+    type: MkDynamicFieldType;
+    label?: string;
+    hint?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /** Initial value when the form (or a new array item) is created. */
+    default?: unknown;
+    validators?: MkDynamicValidators;
+    /** Options for select / multi-select / radio / toggle / autocomplete. */
+    options?: readonly MkDynamicOption[];
+    /**
+     * Extra inputs forwarded to the underlying control — the subset each type
+     * understands (`rows`, `min`, `max`, `step`, `currency`, `accept`,
+     * `multiple`, `swatches`, `language`, …). See the docs table.
+     */
+    props?: Record<string, unknown>;
+    /** Grid columns (1–12) the field spans. Default: the form's `columns` split. */
+    span?: number;
+    /** Render (and enable) only when the condition holds. Hidden fields are excluded from the value. */
+    showWhen?: MkDynamicCondition;
+    /** Disable while the condition holds. */
+    disabledWhen?: MkDynamicCondition;
+}
+/** A nested object: its fields become a child `FormGroup` under `key`. */
+interface MkDynamicGroup {
+    type: 'group';
+    key: string;
+    label?: string;
+    hint?: string;
+    fields: MkDynamicField[];
+    span?: number;
+    /** Columns for the group's own grid (default: inherits the form's). */
+    columns?: number;
+    showWhen?: MkDynamicCondition;
+    disabledWhen?: MkDynamicCondition;
+}
+/** A list of objects: a `FormArray` of groups with add / remove controls. */
+interface MkDynamicArray {
+    type: 'array';
+    key: string;
+    label?: string;
+    hint?: string;
+    /** Fields of one item. */
+    fields: MkDynamicField[];
+    min?: number;
+    max?: number;
+    addLabel?: string;
+    /** Initial items (each is patched over the item defaults). */
+    default?: Record<string, unknown>[];
+    span?: number;
+    columns?: number;
+    showWhen?: MkDynamicCondition;
+    disabledWhen?: MkDynamicCondition;
+}
+/** A heading + description with no value of its own. */
+interface MkDynamicSection {
+    type: 'section';
+    label: string;
+    hint?: string;
+    span?: number;
+    showWhen?: MkDynamicCondition;
+}
+type MkDynamicField = MkDynamicFieldBase | MkDynamicGroup | MkDynamicArray | MkDynamicSection;
+/** The whole form. */
+interface MkDynamicSchema {
+    fields: MkDynamicField[];
+    /** Default number of columns fields are laid out in (1–12). Default 1. */
+    columns?: number;
+}
+declare function mkIsGroup(f: MkDynamicField): f is MkDynamicGroup;
+declare function mkIsArray(f: MkDynamicField): f is MkDynamicArray;
+declare function mkIsSection(f: MkDynamicField): f is MkDynamicSection;
+declare function mkIsValueField(f: MkDynamicField): f is MkDynamicFieldBase;
+
+/** The empty value a field type starts with when no `default` is given. */
+declare function mkDynamicEmptyValue(field: MkDynamicFieldBase): unknown;
+/** Default value object of a field list (groups nested, arrays as item lists). */
+declare function mkDynamicDefaults(fields: readonly MkDynamicField[]): Record<string, unknown>;
+/** Angular validators for one value field, from its declarative `validators` + `required`. */
+declare function mkDynamicValidators(field: MkDynamicFieldBase): ValidatorFn[];
+/** Build the `FormControl` / `FormGroup` / `FormArray` for one field. */
+declare function mkDynamicControl(field: MkDynamicField, value?: unknown): AbstractControl;
+/** A `FormGroup` for a field list; `value` (partial) overrides the defaults. */
+declare function mkDynamicGroup(fields: readonly MkDynamicField[], value?: Record<string, unknown>): FormGroup;
+/** Build the reactive form of a whole schema. */
+declare function mkDynamicForm(schema: MkDynamicSchema, value?: Record<string, unknown>): FormGroup;
+/**
+ * Evaluate a condition against a form value. `value` is normally the whole
+ * form value; inside an array item the item's own value is used, with the
+ * root available under `$root`.
+ */
+declare function mkDynamicCondition(cond: MkDynamicCondition | undefined, value: Record<string, unknown>): boolean;
+/** Depth-first list of every value field with its dotted path. */
+declare function mkDynamicFlatten(fields: readonly MkDynamicField[], prefix?: string): Array<{
+    path: string;
+    field: MkDynamicFieldBase | MkDynamicGroup | MkDynamicArray;
+}>;
+/** Column span a field takes in a grid of `columns`. */
+declare function mkDynamicSpan(field: MkDynamicField, columns: number): number;
+
+/** Context handed to a custom field template. */
+interface MkDynamicFieldContext {
+    $implicit: MkDynamicFieldBase;
+    field: MkDynamicFieldBase;
+    /** The field's `FormControl` — bind it with `[formControl]`. */
+    control: FormControl;
+    /** The current value of the whole form (or array item). */
+    value: Record<string, unknown>;
+}
+/**
+ * Registers a renderer for a custom field type:
+ *
+ * ```html
+ * <mk-dynamic-form [schema]="schema">
+ *   <ng-template mkDynamicField="signature" let-field let-control="control">
+ *     <mk-signature-pad [formControl]="control" />
+ *   </ng-template>
+ * </mk-dynamic-form>
+ * ```
+ *
+ * A field `{ type: 'custom', key: 'sig', props: { renderer: 'signature' } }`
+ * (or any built-in `type` you want to override) then renders this template
+ * inside the usual `mk-form-field`.
+ */
+declare class MkDynamicFieldDef {
+    /** The type (or `props.renderer` name) this template renders. */
+    readonly mkDynamicField: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<MkDynamicFieldContext>;
+    static ngTemplateContextGuard(_dir: MkDynamicFieldDef, ctx: unknown): ctx is MkDynamicFieldContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicFieldDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkDynamicFieldDef, "ng-template[mkDynamicField]", never, { "mkDynamicField": { "alias": "mkDynamicField"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Renders one field list (the root, a group, or one array item) as a grid.
+ * Internal — projected by {@link MkDynamicForm}; recursive for groups/arrays.
+ */
+declare class MkDynamicFields {
+    private readonly root;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    readonly fields: _angular_core.InputSignal<readonly MkDynamicField[]>;
+    readonly group: _angular_core.InputSignal<FormGroup<any>>;
+    readonly columns: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Value the conditions of this level are evaluated against. */
+    readonly scope: _angular_core.InputSignal<Record<string, unknown>>;
+    protected readonly labelPosition: _angular_core.Signal<any>;
+    protected readonly size: _angular_core.Signal<any>;
+    protected control(f: MkDynamicField): AbstractControl;
+    protected formGroup(f: MkDynamicGroup): FormGroup;
+    protected formArray(f: MkDynamicArray): FormArray<FormGroup>;
+    protected isVisible(f: MkDynamicField): boolean;
+    protected span(f: MkDynamicField): number;
+    protected columnsOf(f: MkDynamicGroup | MkDynamicArray): number;
+    protected isGroup: typeof mkIsGroup;
+    protected isArray: typeof mkIsArray;
+    protected isSection: typeof mkIsSection;
+    protected isValue: typeof mkIsValueField;
+    /** Custom template for a value field, if one is registered. */
+    protected customTemplate(f: MkDynamicFieldBase): TemplateRef<MkDynamicFieldContext> | null;
+    protected customContext(f: MkDynamicFieldBase): MkDynamicFieldContext;
+    /** `props.x` with a typed default. */
+    protected p(f: MkDynamicFieldBase, key: string, fallback: unknown): any;
+    protected inputType(f: MkDynamicFieldBase): string;
+    protected itemScope(f: MkDynamicArray, index: number): Record<string, unknown>;
+    protected canAdd(f: MkDynamicArray): boolean;
+    protected canRemove(f: MkDynamicArray): boolean;
+    protected addItem(f: MkDynamicArray): void;
+    protected removeItem(f: MkDynamicArray, index: number): void;
+    protected trackItem(index: number, item: FormGroup): FormGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicFields, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDynamicFields, "mk-dynamic-fields", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "group": { "alias": "group"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Dynamic form — renders a form from a JSON schema and manages one reactive
+ * `FormGroup` for it. Every value field renders inside `mk-form-field`, so
+ * labels, hints, required marks and localised validation messages come from
+ * the schema alone.
+ *
+ * ```html
+ * <mk-dynamic-form [schema]="schema" [(value)]="user" (formSubmit)="save($event)">
+ *   <button mkButton type="submit">Save</button>
+ * </mk-dynamic-form>
+ * ```
+ *
+ * ```ts
+ * schema: MkDynamicSchema = {
+ *   columns: 2,
+ *   fields: [
+ *     { key: 'name', type: 'text', label: 'Name', required: true },
+ *     { key: 'role', type: 'select', label: 'Role', options: roles },
+ *     { key: 'company', type: 'text', label: 'Company', showWhen: { field: 'role', eq: 'b2b' } },
+ *   ],
+ * };
+ * ```
+ *
+ * - Hidden fields (`showWhen` false) are disabled, so `value` only carries
+ *   what the user can see; `form.getRawValue()` has everything.
+ * - `form` is the live `FormGroup` for anything the schema does not cover.
+ * - Custom field types: project an `ng-template[mkDynamicField]`.
+ */
+declare class MkDynamicForm {
+    private readonly destroyRef;
+    /** The schema. Changing it rebuilds the form (values of surviving keys are kept). */
+    readonly schema: _angular_core.InputSignal<MkDynamicSchema>;
+    /** Two-way form value (visible, enabled fields only). */
+    readonly value: _angular_core.ModelSignal<Record<string, unknown>>;
+    /** Disable every control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Label placement forwarded to every `mk-form-field`. */
+    readonly labelPosition: _angular_core.InputSignal<"top" | "float">;
+    /** Control size forwarded to the fields. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Emits the value when the form is submitted and valid. */
+    readonly formSubmit: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    /** Emits when a submit is attempted while invalid (every control is marked touched). */
+    readonly invalidSubmit: _angular_core.OutputEmitterRef<FormGroup<any>>;
+    private readonly defs;
+    private readonly formSignal;
+    private readonly formValue;
+    private subscription;
+    private applying;
+    /** The live reactive form. */
+    get form(): FormGroup;
+    protected readonly formRef: _angular_core.Signal<FormGroup<any>>;
+    /** Value including disabled fields — what conditions are evaluated against. */
+    protected readonly scope: _angular_core.Signal<Record<string, unknown>>;
+    protected readonly columns: _angular_core.Signal<number>;
+    protected readonly fields: _angular_core.Signal<MkDynamicField[]>;
+    /** `true` while every control passes validation. */
+    readonly valid: _angular_core.Signal<boolean>;
+    constructor();
+    private attach;
+    /** Re-evaluate conditions and push the form value to `value`. @internal */
+    sync(): void;
+    private applyConditions;
+    /** Template registered for a custom type / renderer name. @internal */
+    templateFor(name: string): TemplateRef<MkDynamicFieldContext> | null;
+    /** Patch part of the value. */
+    patch(value: Record<string, unknown>): void;
+    /** Reset to the schema defaults (or the given value). */
+    reset(value?: Record<string, unknown>): void;
+    /** Mark every control touched so validation messages show. */
+    touchAll(): void;
+    protected onSubmit(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicForm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDynamicForm, "mk-dynamic-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "formSubmit": "formSubmit"; "invalidSubmit": "invalidSubmit"; }, ["defs"], ["*"], true, never>;
+}
+
+export { MkDynamicFieldDef, MkDynamicFields, MkDynamicForm, mkDynamicCondition, mkDynamicControl, mkDynamicDefaults, mkDynamicEmptyValue, mkDynamicFlatten, mkDynamicForm, mkDynamicGroup, mkDynamicSpan, mkDynamicValidators, mkIsArray, mkIsGroup, mkIsSection, mkIsValueField };
+export type { MkDynamicArray, MkDynamicCondition, MkDynamicField, MkDynamicFieldBase, MkDynamicFieldContext, MkDynamicFieldType, MkDynamicGroup, MkDynamicGroup as MkDynamicGroupField, MkDynamicOption, MkDynamicSchema, MkDynamicSection, MkDynamicValidators };

package/types/mk-kit-ui-feedback.d.ts

@@ -543,13 +543,53 @@ declare class MkDialog {
     readonly titleId: _angular_core.InputSignal<string>;
     /** Hide the header close button. */
     readonly hideClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Let the user move the dialog by dragging its header (pointer / touch) or
+     * with the arrow keys on the grip that appears in the header. Double-click
+     * the header or press Home on the grip to snap back to the centre.
+     */
+    readonly draggable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Let the user resize the dialog from the corner grip (pointer / touch, or
+     * arrow keys on the grip; Home resets). The panel never grows past the
+     * viewport or shrinks below a usable minimum.
+     */
+    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly destroyRef;
+    /** The body-level overlay panel this dialog lives in (`null` when inline). */
+    private panelEl;
+    /** Current drag offset from the centred position, px. */
+    private offset;
     constructor();
     /** Close the surrounding overlay, if any. */
     protected close(): void;
+    /** Snap back to the centred, preset-sized panel. */
+    reset(): void;
+    protected onHeaderPointerDown(event: PointerEvent): void;
+    protected onGripPointerDown(event: PointerEvent): void;
+    protected onResizerPointerDown(event: PointerEvent): void;
+    protected onHeaderDoubleClick(event: MouseEvent): void;
+    protected onGripKeydown(event: KeyboardEvent): void;
+    protected onResizerKeydown(event: KeyboardEvent): void;
+    private static arrowDelta;
+    private startPointer;
+    /** Move the panel to `(x, y)` px from its centred spot, kept inside the viewport. */
+    private moveTo;
+    /** Resize the panel to `w × h` px within [minimum, viewport]. */
+    private resizeTo;
+    /**
+     * Once the user takes hold, the entrance animation must never run again —
+     * toggling `animation` back on (as a transient class would) restarts it,
+     * so the panel would blink after every drag. The class is never removed.
+     */
+    private markMoved;
+    private clampIntoView;
+    private isRtl;
+    private panel;
     /** Point the owning dialog panel's `aria-labelledby` at the title element. */
     private wireLabelledBy;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDialog, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDialog, "mk-dialog", never, { "dialogTitle": { "alias": "dialogTitle"; "required": false; "isSignal": true; }; "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; }, {}, never, ["[mkDialogHeader], mk-dialog-title", "*", "[mkDialogFooter]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDialog, "mk-dialog", never, { "dialogTitle": { "alias": "dialogTitle"; "required": false; "isSignal": true; }; "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; }, {}, never, ["[mkDialogHeader], mk-dialog-title", "*", "[mkDialogFooter]"], true, never>;
 }
 
 /** Data contract for {@link MkConfirmDialog} / `MkDialogService.confirm`. */
@@ -1266,5 +1306,74 @@ declare class MkTourService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkTourService>;
 }
 
-export { MK_TOUR_DATA, MkAlert, MkBanner, MkBottomSheet, MkBottomSheetService, MkConfirmDialog, MkDialog, MkDialogService, MkDialogTitle, MkHovercard, MkHovercardTrigger, MkLoadingBar, MkLoadingBarService, MkNotificationCenter, MkPopconfirm, MkPopconfirmTrigger, MkPopover, MkPopoverTrigger, MkPromptDialog, MkResult, MkSnackbar, MkSnackbarContainer, MkSnackbarRef, MkSnackbarService, MkToast, MkToastContainer, MkToastService, MkTooltip, MkTooltipPanel, MkTourPopup, MkTourService };
+/**
+ * The translucent panel with a spinner that `mkBlockUi` and
+ * `MkBlockUiService` drop over a region or the page.
+ */
+declare class MkBlockUiOverlay {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    readonly message: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBlockUiOverlay, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkBlockUiOverlay, "mk-block-ui-overlay", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Block UI — cover the host element with a translucent panel and spinner
+ * while something loads, so its contents can neither be read nor operated:
+ * a card refreshing, a form submitting, a table re-fetching.
+ *
+ * Children get `inert` (no clicks, no Tab stops) and the host `aria-busy`.
+ * `mkBlockUiDelay` (ms) holds the overlay back for quick operations so the
+ * screen does not flash.
+ *
+ * ```html
+ * <mk-card [mkBlockUi]="saving()" mkBlockUiMessage="Saving…">…</mk-card>
+ * <form [mkBlockUi]="submitting()" [mkBlockUiDelay]="300">…</form>
+ * ```
+ */
+declare class MkBlockUi {
+    private readonly host;
+    private readonly document;
+    private readonly injector;
+    private readonly appRef;
+    /** Block while `true`. */
+    readonly mkBlockUi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text under the spinner (also its accessible label). */
+    readonly mkBlockUiMessage: _angular_core.InputSignal<string>;
+    /** Wait this many ms before showing, to avoid a flash on fast operations. */
+    readonly mkBlockUiDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    private mounted;
+    private timer;
+    constructor();
+    private mount;
+    private unmount;
+    private cancelTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBlockUi, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkBlockUi, "[mkBlockUi]", never, { "mkBlockUi": { "alias": "mkBlockUi"; "required": false; "isSignal": true; }; "mkBlockUiMessage": { "alias": "mkBlockUiMessage"; "required": false; "isSignal": true; }; "mkBlockUiDelay": { "alias": "mkBlockUiDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Block the whole page. Reference-counted: every `block()` returns a release
+ * function, and the overlay disappears once all of them have been called.
+ *
+ * ```ts
+ * const release = this.blockUi.block('Exporting…');
+ * try { await this.api.export(); } finally { release(); }
+ * ```
+ */
+declare class MkBlockUiService {
+    private readonly document;
+    private readonly injector;
+    private readonly appRef;
+    private mounted;
+    private readonly _count;
+    /** Number of active blocks. */
+    readonly count: _angular_core.Signal<number>;
+    /** Show the page overlay (or update its message); call the returned function to release. */
+    block(message?: string): () => void;
+    /** True while the page is blocked. */
+    isBlocked(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBlockUiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkBlockUiService>;
+}
+
+export { MK_TOUR_DATA, MkAlert, MkBanner, MkBlockUi, MkBlockUiOverlay, MkBlockUiService, MkBottomSheet, MkBottomSheetService, MkConfirmDialog, MkDialog, MkDialogService, MkDialogTitle, MkHovercard, MkHovercardTrigger, MkLoadingBar, MkLoadingBarService, MkNotificationCenter, MkPopconfirm, MkPopconfirmTrigger, MkPopover, MkPopoverTrigger, MkPromptDialog, MkResult, MkSnackbar, MkSnackbarContainer, MkSnackbarRef, MkSnackbarService, MkToast, MkToastContainer, MkToastService, MkTooltip, MkTooltipPanel, MkTourPopup, MkTourService };
 export type { MkAlertTone, MkAlertVariant, MkBottomSheetConfig, MkConfirmDialogData, MkDialogConfig, MkDialogSize, MkNotification, MkPromptDialogData, MkResultIconVariant, MkResultStatus, MkResultTone, MkSnackbarConfig, MkSnackbarDismissReason, MkSnackbarItem, MkSnackbarTone, MkToastAction, MkToastConfig, MkToastItem, MkToastTone, MkTourController, MkTourData, MkTourStep };