@meshmakers/octo-ui 3.4.1480 → 3.5.0

package/types/meshmakers-octo-ui-entity-forms.d.ts

@@ -0,0 +1,2648 @@
+import * as Types from '@meshmakers/octo-services';
+import { SecretState, SecretStatusLabels } from '@meshmakers/octo-services';
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders, InjectionToken, TemplateRef, Signal } from '@angular/core';
+import * as _progress_kendo_svg_icons from '@progress/kendo-svg-icons';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { FormGroup, FormControl, ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { EntitySelectDataSource, EntitySelectResult, CommandItem } from '@meshmakers/shared-services';
+import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, FetchDataOptions, FetchResultTyped, TableColumn, RowClassFn, HasUnsavedChanges, UnsavedChangesMessages, DangerConfirmationOptions, ConfirmationService } from '@meshmakers/shared-ui';
+import * as Apollo from 'apollo-angular';
+import { OctoGraphQlDataSource } from '@meshmakers/octo-ui';
+import { Routes } from '@angular/router';
+
+/**
+ * Contract types of the `@meshmakers/octo-ui/entity-forms` entry point (AB#5522).
+ *
+ * The `*Def` interfaces mirror the `System.UI/EntityForm` runtime entities as parsed from the
+ * generic runtime API. The `Resolved*` interfaces are the output of `resolveEntityForm()`: a
+ * form definition matched against the CK metadata of one concrete type, ready to render.
+ */
+
+/** Editor kinds a resolved field can use. */
+type EntityFormEditor = 'text' | 'multiline' | 'password' | 'number' | 'toggle' | 'enum' | 'datetime' | 'url' | 'email' | 'json' | 'yaml' | 'cron' | 'chips' | 'reference' | 'records' | 'unsupported';
+/** Read-only behaviour of a field. `afterCreate` means editable on create, read-only on edit. */
+type ReadOnlyMode = 'never' | 'always' | 'afterCreate';
+/** Mode a form is rendered in. */
+type EntityFormMode = 'create' | 'edit' | 'view';
+/** CK metadata of one attribute of a type or record. */
+interface CkAttributeInfo {
+    /** camelCase, canonical attribute name as returned by the CK API. */
+    attributeName: string;
+    /** AttributeValueType (STRING, INT, INTEGER_64, RECORD_ARRAY, ...). */
+    valueType: string;
+    isOptional: boolean;
+    description?: string | null;
+    defaultValues: unknown[];
+    enumOptions?: {
+        key: number;
+        name: string;
+    }[];
+    /** Versioned record full name (usable with `records(ckId:)`). */
+    ckRecordId?: string | null;
+    /** True when the CK attribute metaData carries `secret = true`. */
+    secret: boolean;
+    /**
+     * The CK metaData `secret` marker as a tri-state (AB#5542): `true`, `false` (explicit opt-out of
+     * the credential-name rule) or `undefined` (no marker).
+     */
+    metaSecret?: boolean;
+}
+/** One association role a type takes part in. */
+interface CkAssociationRoleInfo {
+    rtRoleId: string;
+    navigationPropertyName: string;
+    direction: 'out' | 'in';
+    multiplicity: 'ONE' | 'ZERO_OR_ONE' | 'N';
+    otherRtCkTypeId: string;
+}
+/** CK metadata of one type. */
+interface CkTypeInfo {
+    rtCkTypeId: string;
+    ckTypeIdFullName: string;
+    isAbstract: boolean;
+    /** Ancestor rtCkTypeIds, nearest first, ending with System/Entity; excludes the type itself. */
+    ancestors: string[];
+    /** Attributes in model order as returned (inherited ones included). */
+    attributes: CkAttributeInfo[];
+    associations: CkAssociationRoleInfo[];
+}
+/** CK metadata of one record. */
+interface CkRecordInfo {
+    ckRecordId: string;
+    attributes: CkAttributeInfo[];
+}
+interface EntityFormSectionDef {
+    key: string;
+    title?: string | null;
+    description?: string | null;
+    order?: number | null;
+    collapsed?: boolean | null;
+    columns?: number | null;
+}
+interface EntityFormFieldDef {
+    attributePath: string;
+    sectionKey?: string | null;
+    order?: number | null;
+    label?: string | null;
+    help?: string | null;
+    placeholder?: string | null;
+    editor?: string | null;
+    readOnly?: string | null;
+    required?: boolean | null;
+    width?: string | null;
+    default?: string | null;
+    min?: number | null;
+    max?: number | null;
+    pattern?: string | null;
+    secret?: boolean | null;
+    visibleWhen?: string | null;
+    referenceCkTypeId?: string | null;
+    associationRoleId?: string | null;
+    recordColumns?: string[] | null;
+    hidden?: boolean | null;
+    /**
+     * `EntityFormField.ReferenceDisplayAttributes` (System.UI 2.8.0; host fallback forms may set it
+     * too): non-secret attributes of the reference target shown next to its name in the picker, e.g.
+     * `['repositoryUrl', 'channel']`. Read with an explicit `attributeNames` list of exactly these
+     * names (AB#5547).
+     */
+    referenceDisplayAttributes?: string[] | null;
+}
+/**
+ * One entry of the default list order (AB#5623). Not part of the `System.UI/EntityForm` CK type:
+ * set it in host fallback forms (`provideEntityFormFallbacks`) or pass `defaultSort` to the list.
+ */
+interface EntityFormSortDef {
+    /** Attribute path (any casing) or system property (`rtChangedDateTime`, `rtWellKnownName`, ...). */
+    attributePath: string;
+    /** Default `'asc'`. */
+    direction?: 'asc' | 'desc' | null;
+}
+interface EntityFormColumnDef {
+    attributePath: string;
+    label?: string | null;
+    width?: number | null;
+    display?: string | null;
+}
+/** A parsed `System.UI/EntityForm` entity. */
+interface EntityFormDefinition {
+    rtId: string;
+    rtWellKnownName?: string | null;
+    /** True when `rtBlueprintSource` is empty or null (the form was authored in the tenant). */
+    isTenantForm: boolean;
+    targetCkTypeId: string;
+    includeDerivedTypes: boolean;
+    priority: number;
+    name?: string | null;
+    description?: string | null;
+    category?: string | null;
+    icon?: string | null;
+    canCreate?: boolean | null;
+    canEdit?: boolean | null;
+    canDelete?: boolean | null;
+    canDuplicate?: boolean | null;
+    canExport?: boolean | null;
+    singleton?: boolean | null;
+    singletonWellKnownName?: string | null;
+    customComponent?: string | null;
+    generateRemainingFields?: boolean | null;
+    generatedSectionTitle?: string | null;
+    sections: EntityFormSectionDef[];
+    fields: EntityFormFieldDef[];
+    listColumns: EntityFormColumnDef[];
+    /**
+     * Initial order of the list (AB#5623; host fallback forms only, the CK type has no such
+     * attribute). The user can still sort by any column; without a user sort this order applies.
+     */
+    listDefaultSort?: EntityFormSortDef[] | null;
+}
+/** A parsed `VisibleWhen` expression: `Path=value` or `Path=*` (any value). */
+interface VisibleWhenRule {
+    /** Form control key of the source field (canonical). */
+    path: string;
+    value: string | '*';
+}
+interface ResolvedField {
+    /** Form control name: attributeName | 'rtWellKnownName' | 'assoc:<rtRoleId with . → _>' (`associationFieldKey`). */
+    key: string;
+    kind: 'attribute' | 'system' | 'association';
+    attributeName?: string;
+    valueType?: string;
+    label: string;
+    help?: string;
+    placeholder?: string;
+    editor: EntityFormEditor;
+    required: boolean;
+    readOnly: ReadOnlyMode;
+    width: 'full' | 'half';
+    order: number;
+    /** Already parsed to the form value shape. Applied in create mode only. */
+    defaultValue?: unknown;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    secret: boolean;
+    visibleWhen?: VisibleWhenRule;
+    enumOptions?: {
+        key: number;
+        name: string;
+    }[];
+    record?: {
+        ckRecordId: string;
+        single: boolean;
+        columns: {
+            path: string;
+            label: string;
+        }[];
+    };
+    /** `role` absent means the attribute itself holds the target rtId. */
+    reference?: {
+        targetCkTypeId: string;
+        role?: CkAssociationRoleInfo;
+        multiple: boolean;
+        displayAttributes?: string[];
+        /**
+         * CK metadata of the display attributes on the target type (set by `EntityFormService.resolve`),
+         * used to format their values (enum names, yes/no, dates). Missing when the target type could not
+         * be read; the raw values are shown then.
+         */
+        displayAttributeInfo?: CkAttributeInfo[];
+    };
+    generated: boolean;
+}
+interface ResolvedSection {
+    key: string;
+    title: string | null;
+    description?: string;
+    columns: 1 | 2;
+    collapsed: boolean;
+    generated: boolean;
+    fields: ResolvedField[];
+}
+interface ResolvedListColumn {
+    field: string;
+    label: string;
+    width?: number;
+    /**
+     * Cell rendering. `icon` (AB#5623) shows a BOOLEAN column as a check / x icon with an accessible
+     * name (other value types render as `text`).
+     */
+    display: 'text' | 'chip' | 'date' | 'mono' | 'icon';
+    kind: 'attribute' | 'system';
+    /**
+     * CK value type of an attribute column (ENUM, BOOLEAN, DATE_TIME, ...). The list formats the
+     * cells by it like the reference display does: enum key → name, boolean → yes/no (AB#5547).
+     */
+    valueType?: string;
+    /** Options of an ENUM column (the API returns the key, e.g. `0`). */
+    enumOptions?: {
+        key: number;
+        name: string;
+    }[];
+}
+/**
+ * Sort order of `mm-entity-list` (AB#5623). Same shape as a Kendo `SortDescriptor`; `field` is the
+ * list row field = GraphQL attribute path (camelCase attribute name or system property).
+ */
+interface EntityListSortDescriptor {
+    field: string;
+    dir: 'asc' | 'desc';
+}
+interface ResolvedEntityForm {
+    source: 'tenant' | 'seeded' | 'builtIn';
+    formRtId?: string;
+    formWellKnownName?: string;
+    rtCkTypeId: string;
+    formTargetCkTypeId: string;
+    isAbstract: boolean;
+    includeDerivedTypes: boolean;
+    title: string;
+    description?: string;
+    category?: string;
+    icon?: string;
+    customComponent?: string;
+    capabilities: {
+        canCreate: boolean;
+        canEdit: boolean;
+        canDelete: boolean;
+        canDuplicate: boolean;
+        canExport: boolean;
+        createRequiresSubtype: boolean;
+    };
+    singleton?: {
+        wellKnownName?: string;
+    };
+    sections: ResolvedSection[];
+    listColumns: ResolvedListColumn[];
+    /**
+     * Initial list order from the form definition (`listDefaultSort`, canonicalised; secret
+     * attributes dropped). Absent = server order (today's behaviour).
+     */
+    listDefaultSort?: EntityListSortDescriptor[];
+    /**
+     * Attribute names to read (non-secret fields plus record sub-attribute names, plus the SECRET
+     * fields of {@link secretStateFields}, whose value the server never returns).
+     */
+    readAttributeNames: string[];
+    /** attributeNames of all secret fields (never prefilled, never listed). */
+    secretFields: string[];
+    /**
+     * The secret fields of value type SECRET (AB#5528): their state is read with the values
+     * (`secretIsSet`, later `secretKeyMissing` / `secretSetAt`) and they can be cleared explicitly
+     * (`clearSecretAttributes`). The other secret fields (credential-name / metadata fallback) are
+     * probed for presence with a field filter and cannot be cleared.
+     */
+    secretStateFields?: string[];
+    warnings: string[];
+}
+/**
+ * State of one secret field (AB#5528): the shared octo-services {@link SecretState}
+ * (`keyMissing` implies `isSet: false`). Kept as an alias for existing imports.
+ */
+type EntityFormSecretFieldState = SecretState;
+interface EntityFormValueState {
+    values: Record<string, unknown>;
+    /** Per secret attributeName: set, or stored but unreadable (counts as present for "required"). */
+    secretPresence: Record<string, boolean>;
+    /** Per SECRET attributeName: the full state (badge "Set · set at …" / "Key missing — re-enter"). */
+    secretStates?: Record<string, EntityFormSecretFieldState>;
+    associations: Record<string, {
+        rtId: string;
+        ckTypeId: string;
+        displayName: string;
+    }[]>;
+    rtWellKnownName?: string | null;
+}
+interface EntityFormChangeSet {
+    rtWellKnownName?: string;
+    attributes: {
+        attributeName: string;
+        value: unknown;
+    }[];
+    /** camelCase names of optional SECRET attributes to clear on save (edit mode only, Q8). */
+    clearSecretAttributes?: string[];
+    associations: {
+        roleName: string;
+        targets: {
+            modOption: 'CREATE' | 'DELETE';
+            target: {
+                ckTypeId: string;
+                rtId: string;
+            };
+        }[];
+    }[];
+    isEmpty: boolean;
+}
+
+/**
+ * UI strings of the entity form components (`mm-entity-form`, `mm-entity-list`,
+ * `mm-entity-page` and their field editors).
+ *
+ * Hosts pass a `Partial<EntityFormsMessages>` through the `messages` input; missing keys fall
+ * back to {@link DEFAULT_ENTITY_FORMS_MESSAGES}. Strings containing `{name}` placeholders are
+ * filled with {@link formatEntityFormsMessage}.
+ */
+interface EntityFormsMessages {
+    save: string;
+    cancel: string;
+    delete: string;
+    new: string;
+    edit: string;
+    duplicate: string;
+    export: string;
+    close: string;
+    apply: string;
+    refresh: string;
+    back: string;
+    add: string;
+    remove: string;
+    moveUp: string;
+    moveDown: string;
+    select: string;
+    clear: string;
+    /** Placeholder of a secret field whose value is set on the server. */
+    secretSetPlaceholder: string;
+    /** Placeholder of a secret field without a value on the server. */
+    secretNotSetPlaceholder: string;
+    /** Badge next to a secret field label. */
+    secretBadge: string;
+    /** Help text explaining write-only secrets. */
+    secretHelp: string;
+    /** Badge of a set secret without a timestamp (legacy value). */
+    secretStatusSet: string;
+    /** Badge of a set secret; `{setAt}` = formatted timestamp. */
+    secretStatusSetAt: string;
+    /** Badge of a secret without a value. */
+    secretStatusNotSet: string;
+    /** Badge of a stored secret whose key is not in this environment's key ring (re-entry needed). */
+    secretStatusKeyMissing: string;
+    /** Badge of a required SECRET without a value (same wording as the secrets inventory). */
+    secretStatusNeedsReEntry: string;
+    /** Badge of a secret whose clear is staged for the next save. */
+    secretStatusClearStaged: string;
+    /** Button: stage clearing an optional secret. */
+    secretClear: string;
+    /** Button: undo a staged clear. */
+    secretUndoClear: string;
+    /** Note shown while a clear is staged. */
+    secretClearStagedNote: string;
+    /** Button: reveal the typed (unsaved) value. */
+    secretShow: string;
+    /** Button: mask the typed value again. */
+    secretHide: string;
+    /** Hint when secrets cannot be written (no key ring configured, Q17). */
+    secretWritesDisabled: string;
+    /**
+     * Why Create is blocked: a required secret cannot be entered without a key ring (Q17).
+     * `{fields}` = the field labels.
+     */
+    secretRequiredWritesDisabled: string;
+    /** Status line of a masked multiline secret (PEM); `{lines}` = number of typed lines. */
+    secretMultilineMasked: string;
+    /** Placeholder of a SECRET record member whose stored value is kept when left empty. */
+    secretRecordMemberKeep: string;
+    /** Grid cell of a SECRET record member with a typed, unsaved value (never the value itself). */
+    secretRecordMemberNewValue: string;
+    /** Default title of the section holding fields that the form does not list. */
+    furtherAttributes: string;
+    /** @deprecated Deletes use the danger confirmation keys below (AB#5579); no longer shown. */
+    confirmDeleteTitle: string;
+    /** `{name}` = display name of the entity. @deprecated No longer shown (AB#5579). */
+    confirmDeleteMessage: string;
+    /** `{count}` = number of entities. @deprecated No longer shown (AB#5579). */
+    confirmDeleteManyMessage: string;
+    /**
+     * Danger confirmation (AB#5579): title naming the entity, `{name}` = display name.
+     * Optional for hosts that pass a complete message set; missing = English default.
+     */
+    confirmDeleteNamedTitle?: string;
+    /** Danger confirmation title of a multi-delete; `{count}` = number of entities. */
+    confirmDeleteManyTitle?: string;
+    /** Target shown in a multi-delete confirmation; `{count}` = number of entities. */
+    confirmDeleteManyTarget?: string;
+    /** What a single delete loses. */
+    confirmDeleteConsequence?: string;
+    /** What a multi-delete loses; `{count}` = number of entities. */
+    confirmDeleteManyConsequence?: string;
+    /** Confirming button of a single delete (verb + object). */
+    confirmDeleteConfirmText?: string;
+    /** Confirming button of a multi-delete (verb + object). */
+    confirmDeleteManyConfirmText?: string;
+    /** Row name in the accessible names of the records editor's row buttons; `{index}` = 1-based row. */
+    recordRowLabel?: string;
+    unsavedChangesTitle: string;
+    unsavedChangesMessage: string;
+    discardChanges: string;
+    keepEditing: string;
+    saveSuccess: string;
+    saveError: string;
+    createSuccess: string;
+    deleteSuccess: string;
+    deleteError: string;
+    loadError: string;
+    noChanges: string;
+    /**
+     * Warning when a host `beforeSave` hook vetoed the save without a message of its own (AB#5623).
+     * Optional so that complete message objects of older hosts keep compiling.
+     */
+    saveVetoed?: string;
+    /**
+     * List cell and form field hint of a non-secret value that holds a host-listed placeholder
+     * (`ENTITY_FORM_UNSET_PLACEHOLDER_VALUES`, AB#5623). Optional for older complete message objects.
+     */
+    notConfigured?: string;
+    emptyList: string;
+    emptyRecords: string;
+    emptyReferences: string;
+    entityNotFound: string;
+    formNotFound: string;
+    noFieldsToShow: string;
+    loading: string;
+    validationRequired: string;
+    /** `{min}` = minimum value. */
+    validationMin: string;
+    /** `{max}` = maximum value. */
+    validationMax: string;
+    /** `{pattern}` = regular expression. */
+    validationPattern: string;
+    validationEmail: string;
+    validationUrl: string;
+    validationJson: string;
+    validationNumber: string;
+    /** `{max}` = maximum number of selected entities. */
+    validationMaxItems: string;
+    formInvalid: string;
+    unsupportedEditor: string;
+    chipsPlaceholder: string;
+    referencePlaceholder: string;
+    enumPlaceholder: string;
+    toggleOn: string;
+    toggleOff: string;
+    /** Warning on a record field that cannot be saved safely (sub-attribute name collides with a secret). */
+    recordReadOnlyWarning: string;
+    nestedRecordReadOnly: string;
+    recordRowDialogTitleAdd: string;
+    recordRowDialogTitleEdit: string;
+    columnWellKnownName: string;
+    columnName: string;
+    columnChanged: string;
+    columnCreated: string;
+    columnType: string;
+    columnActions: string;
+    copyId: string;
+    copyRtId: string;
+    copyCkTypeId: string;
+    copyRtCkTypeId: string;
+    copyRtEntityId: string;
+    /** @deprecated No longer shown (AB#5623): both copy actions use {@link copiedId}. */
+    copied: string;
+    /** Tooltip of the Copy ID button in the form header (AB#5623). */
+    copyIdTooltip: string;
+    /** Notification after copying one ID (list menu and form header); `{label}` = RtId, CkTypeId, ... (AB#5623). */
+    copiedId: string;
+    /** Notification when the clipboard is not available (AB#5623). */
+    copyFailed: string;
+    searchPlaceholder: string;
+    /** Header of the optional Type column of the list. */
+    typeColumn: string;
+    selectSubtypeTitle: string;
+    createTitle: string;
+    /** `{name}` = display name of the entity. */
+    editTitle: string;
+    viewTitle: string;
+    readOnlyNotice: string;
+    singletonCreateHint: string;
+}
+/** English defaults; hosts may override any key via the `messages` input. */
+declare const DEFAULT_ENTITY_FORMS_MESSAGES: EntityFormsMessages;
+/** Replaces `{key}` placeholders in a message with the given values. */
+declare function formatEntityFormsMessage(message: string, values: Record<string, string | number>): string;
+/** Merges host overrides over the English defaults. */
+declare function mergeEntityFormsMessages(overrides?: Partial<EntityFormsMessages> | null): EntityFormsMessages;
+/** The secret status labels of a message set, for octo-services `formatSecretStatus`. */
+declare function secretStatusLabelsOf(messages: EntityFormsMessages): SecretStatusLabels;
+
+/**
+ * Loads entity forms and CK metadata and resolves the form for a type (plan §2.3).
+ *
+ * - Forms are read only after the type probe confirms `System.UI/EntityForm` exists (System.UI >=
+ *   2.7.0); otherwise, and when the forms query fails, every type resolves to the built-in form.
+ * - Results are cached per tenant (`TENANT_ID_PROVIDER`, empty string when not provided) in a
+ *   `Map<string, Promise<…>>`; a failed entry is evicted so the next call retries.
+ * - Host fallback forms (`ENTITY_FORM_FALLBACK_FORMS`, `registerFallbackForms`) are appended where
+ *   the normal resolution would end at `form-default` — also when the forms cannot be loaded
+ *   (AB#5524).
+ * - Resolver warnings are logged with `console.warn`.
+ */
+declare class EntityFormService {
+    private readonly probeGql;
+    private readonly formsGql;
+    private readonly ckTypeGql;
+    private readonly ckRecordGql;
+    private readonly tenantIdProvider;
+    private readonly fallbackForms;
+    private readonly cache;
+    private readonly registeredFallbacks;
+    /**
+     * Adds host fallback forms at runtime (see `provideEntityFormFallbacks`). Registering the same
+     * array again is a no-op; a new one drops the cached forms and resolutions.
+     */
+    registerFallbackForms(forms: readonly EntityFormDefinition[]): void;
+    /** Drops every cached form, type, record and resolution (all tenants). */
+    invalidate(): void;
+    /**
+     * All parsed `System.UI/EntityForm` definitions of the current tenant (`[]` when not installed),
+     * plus the host fallback forms for target types without a loaded form.
+     */
+    getForms(): Promise<EntityFormDefinition[]>;
+    private loadForms;
+    /** CK metadata of a type, or `null` when the type does not exist. */
+    getCkType(rtCkTypeId: string): Promise<CkTypeInfo | null>;
+    /** CK metadata of a record (versioned ckRecordId, e.g. `System.UI-2.7.0/EntityFormSection-1`). */
+    getCkRecord(ckRecordId: string): Promise<CkRecordInfo | null>;
+    /**
+     * Loads every record reachable from the given attributes (recursively), keyed by ckRecordId.
+     * Records that cannot be loaded are left out.
+     */
+    getRecordsFor(type: CkTypeInfo): Promise<Record<string, CkRecordInfo>>;
+    /**
+     * Resolves the form for a type. Rejects when the CK type does not exist; falls back to the
+     * built-in form when no form applies or the forms cannot be loaded.
+     */
+    resolve(rtCkTypeId: string): Promise<ResolvedEntityForm>;
+    /**
+     * Adds the target type's CK metadata of the display attributes to every reference field that
+     * has `displayAttributes` (AB#5547: the channel enum showed its key `0` instead of "Release").
+     * A display attribute marked secret on the target is dropped (it must never be read).
+     */
+    private attachDisplayAttributeInfo;
+    /**
+     * Resolves by form key: the form's `rtWellKnownName` (`form-sftp-configuration`) or the kebab
+     * type key (`sftp-configuration`, matched against `form-<key>` and then against the kebab-cased
+     * name of each form's target type). The type's form is then resolved normally, so a tenant form
+     * for the same type still wins. Returns `null` when no form matches the key.
+     */
+    resolveByFormKey(formKey: string): Promise<ResolvedEntityForm | null>;
+    private tenantId;
+    private cached;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EntityFormService>;
+}
+/**
+ * Registers host fallback forms in the root `EntityFormService` when the providing (lazy) route's
+ * environment injector is created — one service, one cache, and the entry point stays out of the
+ * initial bundle (AB#5524). Put it into the `providers` of every lazy route that renders entity
+ * forms; registering the same array several times is harmless.
+ */
+declare function provideEntityFormFallbacks(forms: readonly EntityFormDefinition[]): EnvironmentProviders;
+
+/** How to find the entity to load. `ckTypeId` defaults to the form's type (derived types match). */
+type EntityFormLoadKey = {
+    rtId: string;
+    ckTypeId?: string;
+} | {
+    wellKnownName: string;
+    ckTypeId?: string;
+};
+/** Result of {@link EntityFormDataService.load}. */
+interface EntityFormLoadResult {
+    rtId: string;
+    ckTypeId: string;
+    rtDisplayName?: string | null;
+    state: EntityFormValueState;
+}
+/** One selected reference / association target as held by a reference control. */
+interface EntityFormTargetRef {
+    rtId: string;
+    ckTypeId: string;
+    displayName: string;
+}
+/**
+ * Reads and writes entity values for the entity form (plan §2.3, rules D5/D6).
+ *
+ * SECURITY: values are read with an explicit `attributeNames` list (`model.readAttributeNames`
+ * minus every secret, never omitted — omission returns every attribute). SECRET attributes
+ * (AB#5528, `model.secretStateFields`) are listed too: the server returns `value: null` and
+ * `secretIsSet`. Fallback secrets (credential name / metadata on non-SECRET attributes) are only
+ * probed for presence (`IS_NOT_NULL` + `totalCount`). Mutations never select attributes; an
+ * explicit clear goes through `clearSecretAttributes`.
+ */
+declare class EntityFormDataService {
+    private readonly valuesGql;
+    private readonly presenceGql;
+    private readonly targetsGql;
+    private readonly definitionsGql;
+    private readonly referenceOptionsGql;
+    private readonly createGql;
+    private readonly updateGql;
+    private readonly deleteGql;
+    private readonly listGql;
+    private readonly countGql;
+    private readonly formService;
+    private readonly secretPlaceholders;
+    /**
+     * The attribute names to read for a model: `readAttributeNames` with every secret removed except
+     * the SECRET fields (`secretStateFields`, read for their state only). Always an array (an omitted
+     * list would return secrets).
+     */
+    static readAttributeNamesFor(model: ResolvedEntityForm): string[];
+    /**
+     * Number of entities of a type (e.g. for a settings overview). Without `includeDerivedTypes`
+     * only entities of exactly that type are counted (`runtimeEntities(ckId)` includes derived
+     * types by default). Selects only `totalCount` — no items, so no attributes are resolved
+     * (with `attributes(attributeNames: [])` per item the count failed with CK_CACHE whenever one
+     * item's type could not be resolved, AB#5523). Errors reject the promise without a toast.
+     */
+    count(ckTypeId: string, includeDerivedTypes?: boolean): Promise<number>;
+    /** Loads values, secret presence and associations of one entity in parallel; `null` if not found. */
+    load(model: ResolvedEntityForm, key: EntityFormLoadKey): Promise<EntityFormLoadResult | null>;
+    /** Creates an entity; returns its rtId. */
+    create(model: ResolvedEntityForm, ckTypeId: string, changeSet: EntityFormChangeSet): Promise<string>;
+    /**
+     * Updates an entity with exactly the change set (partial update: attributes that are not sent
+     * keep their value — verified live, including the presence of secrets). `rtWellKnownName` is
+     * never changed on update. Staged secret clears are sent as `clearSecretAttributes` (Q8).
+     */
+    update(rtId: string, ckTypeId: string, changeSet: EntityFormChangeSet): Promise<void>;
+    /** Deletes entities (default strategy ARCHIVE). */
+    delete(entities: {
+        rtId: string;
+        ckTypeId: string;
+    }[], strategy?: 'ARCHIVE' | 'ERASE'): Promise<boolean>;
+    private associationInputs;
+    private loadRecords;
+    /**
+     * "Set / not set" per secret: not null AND — for STRING secrets — not the empty string (an empty
+     * string is "no secret", AB#5524; same rule as the Studio's service account page) and none of the
+     * host's placeholder values (`ENTITY_FORM_SECRET_PLACEHOLDER_VALUES`, AB#5623). SECRET-typed
+     * attributes are not probed here: their state comes from the server.
+     */
+    private loadSecretPresence;
+    private loadAssociations;
+    private loadAssociationTargets;
+    /** Display names for ids, grouped by type; selects only the `name` attribute (secret-safe). */
+    private lookupDisplayNames;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormDataService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EntityFormDataService>;
+}
+
+/**
+ * What a label belongs to (AB#5623):
+ * - `formTitle` / `formDescription` — the form's name and description (`key` = the form key, else
+ *   the runtime CK type id);
+ * - `section` / `sectionDescription` — a section title / description (`key` = section key);
+ * - `field` / `help` / `placeholder` — a field's label, help text and placeholder
+ *   (`key` = the field key: camelCase attribute name, `rtWellKnownName` or `assoc:<role>`);
+ * - `listColumn` — a list column title (`key` = the column field);
+ * - `recordColumn` — a column of a record grid (`key` = the record sub-attribute path,
+ *   `attributeName` = the record attribute);
+ * - `enumOption` — the display text of an enum value (`key` = the enum value name, `enumKey` = its
+ *   numeric key, `attributeName` = the ENUM attribute).
+ */
+type EntityFormLabelKind = 'formTitle' | 'formDescription' | 'section' | 'sectionDescription' | 'field' | 'help' | 'placeholder' | 'listColumn' | 'recordColumn' | 'enumOption';
+/** One label lookup of {@link EntityFormLabelResolver}. */
+interface EntityFormLabelRequest {
+    kind: EntityFormLabelKind;
+    /**
+     * Runtime CK type the label belongs to (`Basic.Accounting/BankAccount`). For enum options of a
+     * reference display attribute this is the reference target type.
+     */
+    rtCkTypeId: string;
+    /** Well-known name (else rtId) of the form definition, when the form came from one. */
+    formKey?: string;
+    /** See {@link EntityFormLabelKind}. */
+    key: string;
+    /** The attribute an `enumOption` / `recordColumn` belongs to (camelCase). */
+    attributeName?: string;
+    /** Numeric key of an `enumOption`. */
+    enumKey?: number;
+    /** The text shown without a resolver (form definition text, else derived from the CK model). */
+    defaultText: string;
+}
+/**
+ * Host hook that translates the texts of an entity form (AB#5623): field labels, help texts,
+ * placeholders, section titles, form title, list column titles, record columns and enum option
+ * texts. Return `null`, `undefined` or `''` to keep {@link EntityFormLabelRequest.defaultText}.
+ *
+ * The resolver is called inside Angular `computed`s: when it reads a signal (e.g. the current
+ * language), the forms re-render on a change of that signal. A resolver that reads no signal is
+ * evaluated once per model; pass a new function to the `labelResolver` input to refresh it.
+ * A language change never rebuilds the form controls, so unsaved edits are kept.
+ *
+ * Fixed UI texts (buttons, notifications, validation messages) are translated with the `messages`
+ * input ({@link EntityFormsMessages}), not with this hook.
+ */
+type EntityFormLabelResolver = (request: EntityFormLabelRequest) => string | null | undefined;
+/**
+ * App-wide {@link EntityFormLabelResolver} for `mm-entity-form`, `mm-entity-list` and
+ * `mm-entity-page`. Their `labelResolver` input wins over this token. Not provided = the texts of
+ * the form definition / CK model are shown unchanged (today's behaviour).
+ */
+declare const ENTITY_FORM_LABEL_RESOLVER: InjectionToken<EntityFormLabelResolver>;
+/**
+ * Resolves one label; falls back to the default text when there is no resolver, no translation,
+ * or the resolver throws (logged once per resolver with `console.warn`).
+ */
+declare function resolveEntityFormLabel(resolver: EntityFormLabelResolver | null | undefined, request: EntityFormLabelRequest): string;
+/** The list columns of a model with translated titles and enum texts (unchanged without a resolver). */
+declare function localizeEntityListColumns(model: ResolvedEntityForm, resolver: EntityFormLabelResolver | null | undefined): ResolvedListColumn[];
+/** Translated form title (unchanged without a resolver). */
+declare function localizeEntityFormTitle(model: ResolvedEntityForm, resolver: EntityFormLabelResolver | null | undefined): string;
+/**
+ * A copy of a resolved form with every display text passed through the resolver (AB#5623). Keys,
+ * attribute names and enum keys are unchanged, so form controls, change sets and queries are not
+ * affected. Returns the model itself when there is no resolver.
+ */
+declare function localizeEntityForm(model: ResolvedEntityForm, resolver: EntityFormLabelResolver | null | undefined): ResolvedEntityForm;
+
+/** What a {@link EntityFormBeforeSaveHook} learns about the save besides the change set. */
+interface EntityFormBeforeSaveContext {
+    /** `create` or `edit` (a view form never saves). */
+    mode: Exclude<EntityFormMode, 'view'>;
+    /** Runtime CK type id of the entity that is saved (the concrete type in create mode). */
+    ckTypeId: string;
+    /** rtId of the entity in edit mode; absent in create mode. */
+    rtId?: string;
+    /** The resolved form (fields, sections, secret field names) - metadata only, no values. */
+    form: ResolvedEntityForm;
+}
+/**
+ * Result of a {@link EntityFormBeforeSaveHook}:
+ * - a change set → saved instead of the original one (`isEmpty` is recomputed);
+ * - `undefined` / `void` / `true` → the change set handed to the hook is saved, including any
+ *   in-place changes the hook made to it;
+ * - `null` / `false` → the save is vetoed silently (the hook told the user itself, or nothing
+ *   needs saying). To veto with a message, throw an {@link EntityFormSaveVeto}.
+ */
+type EntityFormBeforeSaveResult = EntityFormChangeSet | boolean | null | undefined | void;
+/**
+ * Host hook run right before an entity form is saved (AB#5623), after validation — e.g. to
+ * normalise values (trim texts, format IBAN / BIC / phone numbers, lower-case an e-mail) or to
+ * derive attributes (`NormalizedEmail` from `Email`). It may be synchronous or return a
+ * `Promise` / `Observable` (the first emitted value counts).
+ *
+ * - Attribute names in `changeSet.attributes` are the camelCase CK attribute names
+ *   (`email`, `normalizedEmail`); values are wire values (strings, numbers, enum keys, …).
+ * - Edit mode: the change set holds only changed attributes (D6). A hook that derives an
+ *   attribute from another one therefore acts only when the source is in the change set; it may
+ *   add attributes that are not in the form.
+ * - **Secrets:** the hook sees nothing beyond the change set. A SECRET attribute appears there
+ *   only as the write value the user just typed into this form (or in `clearSecretAttributes`
+ *   when a clear is staged) — never a stored value, which the form never reads. Do not log the
+ *   change set.
+ * - Throw an {@link EntityFormSaveVeto} to stop the save with a message for the user; any other
+ *   error also stops the save and is reported like a failed save.
+ *
+ * Provide it as the `beforeSave` input of `mm-entity-form` / `mm-entity-page`, as the
+ * `beforeSave` option of `entityFormRoutes` (route data key `entityFormBeforeSave`), or via
+ * {@link ENTITY_FORM_BEFORE_SAVE} on a route / root injector. Precedence: input > route data >
+ * token.
+ */
+type EntityFormBeforeSaveHook = (changeSet: EntityFormChangeSet, context: EntityFormBeforeSaveContext) => EntityFormBeforeSaveResult | Promise<EntityFormBeforeSaveResult> | Observable<EntityFormBeforeSaveResult>;
+/** Injection token of a {@link EntityFormBeforeSaveHook} (lowest precedence, see there). */
+declare const ENTITY_FORM_BEFORE_SAVE: InjectionToken<EntityFormBeforeSaveHook>;
+/**
+ * Thrown by a {@link EntityFormBeforeSaveHook} to stop a save on purpose. `userMessage` (already
+ * translated by the host) is shown as a warning; without it the generic `saveVetoed` message is
+ * shown.
+ */
+declare class EntityFormSaveVeto extends Error {
+    readonly userMessage?: string | undefined;
+    constructor(userMessage?: string | undefined);
+}
+/** Outcome of {@link runEntityFormBeforeSave}. */
+type EntityFormBeforeSaveOutcome = {
+    kind: 'save';
+    changeSet: EntityFormChangeSet;
+} | {
+    kind: 'veto';
+    message?: string;
+} | {
+    kind: 'error';
+    error: unknown;
+};
+/** True for a thrown {@link EntityFormSaveVeto} (also across bundle copies, by name). */
+declare function isEntityFormSaveVeto(error: unknown): error is EntityFormSaveVeto;
+/**
+ * Runs the host hook on a copy of the change set (the caller's object is never touched) and
+ * normalises its result. Absent hook = save unchanged.
+ */
+declare function runEntityFormBeforeSave(hook: EntityFormBeforeSaveHook | null | undefined, changeSet: EntityFormChangeSet, context: EntityFormBeforeSaveContext): Promise<EntityFormBeforeSaveOutcome>;
+
+/**
+ * Values a host puts into a form (AB#5623), keyed by field key: the camelCase attribute name (any
+ * casing is accepted), `rtWellKnownName`, or the association field key (`assoc:<role>`).
+ *
+ * Values use the form value shape (as in {@link EntityFormValueState.values}): strings, numbers,
+ * booleans, `Date` for DATE_TIME, arrays for chips and records, and for references either a bare
+ * rtId or `{ rtId, ckTypeId, displayName }[]`. Secret fields are never prefilled.
+ */
+type EntityFormPrefillValues = Readonly<Record<string, unknown>>;
+/** Options of {@link entityFormPrefillState}. */
+interface EntityFormPrefillOptions {
+    /** Well-known name of the entity to create (carried even when the form has no such field). */
+    rtWellKnownName?: string | null;
+}
+/**
+ * Builds the `state` of `<mm-entity-form mode="create">` from host values (AB#5623): a prefilled
+ * value wins over the field's default, everything else starts empty. Equivalent to the form's
+ * `initialValues` input; use it when the host already passes a `state`.
+ */
+declare function entityFormPrefillState(values: EntityFormPrefillValues | null | undefined, options?: EntityFormPrefillOptions): EntityFormValueState;
+/**
+ * Merges host values over a create-mode state (host values win). Returns the state unchanged when
+ * there are no values. Canonicalise the keys first ({@link canonicaliseEntityFormPrefill}).
+ */
+declare function mergeEntityFormPrefill(state: EntityFormValueState | null | undefined, values: EntityFormPrefillValues | null | undefined): EntityFormValueState | null;
+/**
+ * Host values re-keyed to the form's field keys (AB#5623). Unknown keys are kept as they are
+ * (`rtWellKnownName` is always kept); secret fields are dropped (never prefilled); a bare rtId for
+ * a reference field becomes the reference editor's `{ rtId, ckTypeId, displayName }[]` value.
+ */
+declare function canonicaliseEntityFormPrefill(model: ResolvedEntityForm, values: EntityFormPrefillValues | null | undefined): Record<string, unknown>;
+
+/**
+ * Secret state shown next to a secret field (AB#5542 / AB#5544 item 4): set on the server, not set
+ * (`needsReEntry` for a required SECRET — same wording as the secrets inventory),
+ * stored but unreadable (`keyMissing`, re-entry needed), clear staged for the next save, or `null`
+ * (not a secret, or create mode — then the plain "Secret" badge is shown).
+ */
+type EntityFormSecretState = 'set' | 'notSet' | 'needsReEntry' | 'keyMissing' | 'clearStaged' | null;
+
+/**
+ * Renders a {@link ResolvedEntityForm} as a reactive form: sections (1 or 2 columns,
+ * collapsible), one field shell per field and the editor chosen by the resolver.
+ *
+ * Rules applied here (see the plan, §2.4):
+ * - A field hidden by `VisibleWhen` has its control disabled, so it neither validates nor appears
+ *   in the change set. `Path=*` on a secret source counts the server-side presence as a value.
+ * - Secrets are never prefilled; the badge says whether a value is set (also for read-only users).
+ *   Empty = unchanged. An optional SECRET can be cleared: the clear is staged and sent on Save as
+ *   `clearSecretAttributes` (mutually exclusive with a new value). Without a key ring
+ *   (`ENTITY_FORM_SECRET_KEY_RING_CONFIGURED` = false) secret inputs are disabled with a hint; the
+ *   signal may change at any time (status loaded asynchronously) and the controls follow it. In
+ *   create mode a required secret that cannot be entered blocks the form: `isValid()` is false and
+ *   `saveBlockedReason()` names the fields, so hosts disable Create with that reason (Q17: no late
+ *   `SecretEncryptionNotConfigured` / "required secret missing" error on save).
+ * - `afterCreate` fields are read-only outside create mode; `readOnly`, `view` mode or
+ *   `capabilities.canEdit === false` (edit mode) make every field read-only.
+ * - The change set holds only dirty controls (D6), built by `buildChangeSet`.
+ * - Texts (labels, help, sections, enum options, record columns) go through the label resolver
+ *   (`labelResolver` input or `ENTITY_FORM_LABEL_RESOLVER`, AB#5623); a language change re-renders
+ *   the texts without rebuilding the controls.
+ * - Host prefill (AB#5623): `initialValues` in create mode, `patchValues()` at any time.
+ * - Before-save hook (AB#5623): `beforeSave` input / `ENTITY_FORM_BEFORE_SAVE`, applied by
+ *   {@link getChangeSetForSave}; secrets reach it only as values typed into this form.
+ * - Unset placeholders (AB#5623, `ENTITY_FORM_UNSET_PLACEHOLDER_VALUES`): a non-secret field whose
+ *   stored / default / prefilled value is a listed placeholder starts empty with the
+ *   `notConfigured` hint; untouched it is not part of the change set, so the placeholder is never
+ *   written back. Secrets are never affected.
+ */
+declare class EntityFormComponent {
+    private readonly destroyRef;
+    private readonly keyRingConfigured;
+    private readonly injectedLabelResolver;
+    private readonly injectedBeforeSave;
+    private readonly unsetPlaceholders;
+    readonly model: _angular_core.InputSignal<ResolvedEntityForm>;
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    readonly state: _angular_core.InputSignal<EntityFormValueState | null | undefined>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly messages: _angular_core.InputSignal<Partial<EntityFormsMessages>>;
+    /** Record metadata keyed by versioned ckRecordId; improves type conversion of record sub-values. */
+    readonly records: _angular_core.InputSignal<Record<string, CkRecordInfo>>;
+    /**
+     * Translates field labels, help texts, section titles, enum option texts and record columns
+     * (AB#5623). Wins over `ENTITY_FORM_LABEL_RESOLVER`; absent = the definition / CK texts.
+     */
+    readonly labelResolver: _angular_core.InputSignal<EntityFormLabelResolver | null | undefined>;
+    /**
+     * Host prefill of a create form (AB#5623), keyed by field key / attribute name (any casing).
+     * Wins over the field defaults and over `state.values`; secrets are never prefilled. The values
+     * are the starting point of the form (not "dirty"); a create sends every non-empty value anyway.
+     * Ignored in edit / view mode — use {@link patchValues} there.
+     */
+    readonly initialValues: _angular_core.InputSignal<Readonly<Record<string, unknown>> | null | undefined>;
+    /**
+     * Hook run by {@link getChangeSetForSave} (AB#5623): may modify the change set or veto the save.
+     * Wins over `ENTITY_FORM_BEFORE_SAVE`. `mm-entity-page` runs its own (input > route data >
+     * token), so set it there when the page saves. See `EntityFormBeforeSaveHook`.
+     */
+    readonly beforeSave: _angular_core.InputSignal<EntityFormBeforeSaveHook | null | undefined>;
+    readonly changeSetChange: _angular_core.OutputEmitterRef<EntityFormChangeSet>;
+    readonly validChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly dirtyChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly chevronDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly chevronRightIcon: _progress_kendo_svg_icons.SVGIcon;
+    /** Stable empty list for reference fields without display attributes. */
+    protected readonly noDisplayAttributes: readonly string[];
+    protected readonly noDisplayAttributeInfo: readonly CkAttributeInfo[];
+    protected readonly resolvedMessages: _angular_core.Signal<EntityFormsMessages>;
+    /** The effective label resolver (input, else the injected one, else none). */
+    private readonly effectiveLabelResolver;
+    /**
+     * The model as rendered: every text passed through the label resolver (AB#5623). Keys are
+     * unchanged, so the controls built from {@link model} match it.
+     */
+    protected readonly view: _angular_core.Signal<ResolvedEntityForm>;
+    protected readonly form: _angular_core.WritableSignal<FormGroup<Record<string, FormControl<unknown>>>>;
+    /** Bumped on every form event so OnPush children re-evaluate errors. */
+    protected readonly revision: _angular_core.WritableSignal<number>;
+    /** Raw values (disabled controls included) for VisibleWhen evaluation. */
+    private readonly rawValues;
+    private readonly collapsed;
+    /** Keys of the fields whose stored value was an unset placeholder (AB#5623); they start empty. */
+    protected readonly unsetPlaceholderFields: _angular_core.WritableSignal<ReadonlySet<string>>;
+    /** attributeNames of secrets whose clear is staged for the next save (Q8). */
+    private readonly clearedSecrets;
+    /** Value snapshot taken when the form was built (D6 baseline). */
+    private baselineValues;
+    /** The state the form was built from (input `state` plus host prefill). */
+    private builtState;
+    private formSub?;
+    private lastValid?;
+    private lastDirty?;
+    protected readonly secretPresence: _angular_core.Signal<Record<string, boolean>>;
+    protected readonly formReadOnly: _angular_core.Signal<boolean>;
+    /** No key ring in this environment (Q17): secret inputs are disabled with a hint. */
+    protected readonly secretWritesDisabled: _angular_core.Signal<boolean>;
+    /** The `secretWritesDisabled` value the controls were last enabled / disabled for. */
+    private appliedSecretWritesDisabled?;
+    /** Visibility per field key, from VisibleWhen and the current raw values. */
+    protected readonly visibility: _angular_core.Signal<Record<string, boolean>>;
+    /**
+     * Why the form cannot be saved although every enabled control is valid, or `null`: in create
+     * mode without a key ring (Q17), a visible, writable, required secret cannot be entered — the
+     * server would reject the create (required secret missing). Hosts disable Create and show this.
+     * In edit mode a missing required secret does not block saving other fields (the server only
+     * enforces required secrets on create).
+     */
+    readonly saveBlockedReason: _angular_core.Signal<string | null>;
+    /** Default item of optional enum dropdowns. */
+    protected readonly enumDefaultItem: _angular_core.Signal<{
+        key: null;
+        name: string;
+    }>;
+    constructor();
+    /** Change set of the current values (only dirty controls on edit). */
+    getChangeSet(): EntityFormChangeSet;
+    /**
+     * The change set to save, after the before-save hook (`beforeSave` input, else
+     * `ENTITY_FORM_BEFORE_SAVE`; AB#5623) — for hosts that render `mm-entity-form` and save
+     * themselves. The form never shows notifications: on `veto` / `error` the host tells the user
+     * (e.g. `outcome.message ?? messages.saveVetoed`). View mode, and an edit form without changes,
+     * skip the hook. `context.rtId` names the edited entity; `context.ckTypeId` defaults to the
+     * form's runtime CK type.
+     */
+    getChangeSetForSave(context?: {
+        rtId?: string;
+        ckTypeId?: string;
+    }): Promise<EntityFormBeforeSaveOutcome>;
+    /** True when any editable, visible control differs from the value it was built with. */
+    isDirty(): boolean;
+    /** True when every enabled control is valid and nothing blocks saving ({@link saveBlockedReason}). */
+    isValid(): boolean;
+    /** Marks every control as touched so validation errors become visible. */
+    markAllAsTouched(): void;
+    /** Rebuilds the form from the current inputs, discarding user edits. */
+    reset(): void;
+    /**
+     * Sets form values from the host (AB#5623), e.g. a "Prefill from user" action. Keys are field
+     * keys or attribute names (any casing). The values always count as user edits: the form gets
+     * dirty (compared with the values it was built from), the unsaved-changes guard applies and the
+     * change set sends them. To start a create form with values that are NOT edits, use the
+     * `initialValues` input instead. Secret fields, read-only fields and unknown keys are skipped.
+     * Returns the field keys that were set.
+     */
+    patchValues(values: EntityFormPrefillValues): string[];
+    protected control(key: string): FormControl<unknown>;
+    protected isFieldVisible(field: ResolvedField): boolean;
+    protected visibleFieldCount(section: ResolvedSection): number;
+    protected isCollapsed(section: ResolvedSection): boolean;
+    protected toggleSection(section: ResolvedSection): void;
+    protected isReadOnly(field: ResolvedField): boolean;
+    protected isRequired(field: ResolvedField): boolean;
+    protected secretState(field: ResolvedField): EntityFormSecretState;
+    protected secretSetAt(field: ResolvedField): Date | null;
+    /**
+     * "Clear" is offered for an optional SECRET (only SECRET attributes accept
+     * `clearSecretAttributes`) that holds a value (set or key missing), in edit mode, when the field
+     * is writable. Required secrets cannot be cleared (Q8).
+     */
+    protected canClearSecret(field: ResolvedField): boolean;
+    protected isSecretClearStaged(field: ResolvedField): boolean;
+    /** Stages or undoes clearing a secret; a staged clear empties and disables the input. */
+    protected setSecretClearStaged(field: ResolvedField, staged: boolean): void;
+    protected placeholder(field: ResolvedField): string;
+    /** Q17 applies to SECRET-typed fields only (the encryption key ring is not needed for fallback secrets). */
+    protected isSecretWriteBlocked(field: ResolvedField): boolean;
+    protected isIntegerField(field: ResolvedField): boolean;
+    protected isIntArray(field: ResolvedField): boolean;
+    protected displayUnsupported(field: ResolvedField): string;
+    /** `state` with the host prefill merged in (create mode only). */
+    private withPrefill;
+    private rebuild;
+    /**
+     * Empties the fields that hold an unset placeholder (AB#5623) before the baseline is taken, so an
+     * untouched field is "no change" and the placeholder is never written back.
+     */
+    private clearUnsetPlaceholders;
+    /** Attribute-held references store a bare rtId; the reference editor works with an array. */
+    private normaliseAttributeReferences;
+    private onFormEvent;
+    /**
+     * Enables/disables controls by visibility. A hidden field is always disabled; a visible field
+     * is enabled unless it is read-only.
+     */
+    private applyVisibility;
+    /** Values of enabled controls only (hidden and read-only fields are absent). */
+    private enabledValues;
+    private emitState;
+    private bump;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityFormComponent, "mm-entity-form", never, { "model": { "alias": "model"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "records": { "alias": "records"; "required": false; "isSignal": true; }; "labelResolver": { "alias": "labelResolver"; "required": false; "isSignal": true; }; "initialValues": { "alias": "initialValues"; "required": false; "isSignal": true; }; "beforeSave": { "alias": "beforeSave"; "required": false; "isSignal": true; }; }, { "changeSetChange": "changeSetChange"; "validChange": "validChange"; "dirtyChange": "dirtyChange"; }, never, never, true, never>;
+}
+
+type EntityFormGetReferenceOptionsQueryVariablesDto = Types.Exact<{
+    ckTypeId: Types.Scalars['String']['input'];
+    first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    after?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    searchFilter?: Types.InputMaybe<Types.SearchFilterDto>;
+    fieldFilters?: Types.InputMaybe<Array<Types.InputMaybe<Types.FieldFilterDto>> | Types.InputMaybe<Types.FieldFilterDto>>;
+    sort?: Types.InputMaybe<Array<Types.InputMaybe<Types.SortDto>> | Types.InputMaybe<Types.SortDto>>;
+}>;
+type EntityFormGetReferenceOptionsQueryDto = {
+    __typename?: 'OctoQuery';
+    runtime?: {
+        __typename?: 'RuntimeModelQuery';
+        runtimeEntities?: {
+            __typename?: 'RtEntityGenericDtoConnection';
+            totalCount?: number | null;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                endCursor?: string | null;
+                hasNextPage: boolean;
+            };
+            items?: Array<{
+                __typename?: 'RtEntity';
+                rtId: any;
+                ckTypeId: any;
+                rtWellKnownName?: string | null;
+                rtDisplayName: string;
+                rtDisplayDescription?: string | null;
+                attributes?: {
+                    __typename?: 'RtEntityAttributeDtoConnection';
+                    items?: Array<{
+                        __typename?: 'RtEntityAttribute';
+                        attributeName?: string | null;
+                        value?: any | null;
+                    } | null> | null;
+                } | null;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+declare class EntityFormGetReferenceOptionsDtoGQL extends Apollo.Query<EntityFormGetReferenceOptionsQueryDto, EntityFormGetReferenceOptionsQueryVariablesDto> {
+    document: Apollo.TypedDocumentNode<unknown, unknown>;
+    constructor(apollo: Apollo.Apollo);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormGetReferenceOptionsDtoGQL, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EntityFormGetReferenceOptionsDtoGQL>;
+}
+
+type EntityFormGetReferenceOptionsWithAttributesQueryVariablesDto = Types.Exact<{
+    ckTypeId: Types.Scalars['String']['input'];
+    first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    after?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    searchFilter?: Types.InputMaybe<Types.SearchFilterDto>;
+    fieldFilters?: Types.InputMaybe<Array<Types.InputMaybe<Types.FieldFilterDto>> | Types.InputMaybe<Types.FieldFilterDto>>;
+    sort?: Types.InputMaybe<Array<Types.InputMaybe<Types.SortDto>> | Types.InputMaybe<Types.SortDto>>;
+    attributeNames: Array<Types.InputMaybe<Types.Scalars['String']['input']>> | Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+type EntityFormGetReferenceOptionsWithAttributesQueryDto = {
+    __typename?: 'OctoQuery';
+    runtime?: {
+        __typename?: 'RuntimeModelQuery';
+        runtimeEntities?: {
+            __typename?: 'RtEntityGenericDtoConnection';
+            totalCount?: number | null;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                endCursor?: string | null;
+                hasNextPage: boolean;
+            };
+            items?: Array<{
+                __typename?: 'RtEntity';
+                rtId: any;
+                ckTypeId: any;
+                rtWellKnownName?: string | null;
+                rtDisplayName: string;
+                rtDisplayDescription?: string | null;
+                attributes?: {
+                    __typename?: 'RtEntityAttributeDtoConnection';
+                    items?: Array<{
+                        __typename?: 'RtEntityAttribute';
+                        attributeName?: string | null;
+                        value?: any | null;
+                    } | null> | null;
+                } | null;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+declare class EntityFormGetReferenceOptionsWithAttributesDtoGQL extends Apollo.Query<EntityFormGetReferenceOptionsWithAttributesQueryDto, EntityFormGetReferenceOptionsWithAttributesQueryVariablesDto> {
+    document: Apollo.TypedDocumentNode<unknown, unknown>;
+    constructor(apollo: Apollo.Apollo);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormGetReferenceOptionsWithAttributesDtoGQL, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EntityFormGetReferenceOptionsWithAttributesDtoGQL>;
+}
+
+/**
+ * How the display attributes of a reference target (`referenceDisplayAttributes`, AB#5547) are
+ * turned into text: by the CK value type of each attribute. Without metadata for an attribute the
+ * raw value is shown (booleans still as yes/no).
+ */
+interface ReferenceDisplayFormat {
+    /** CK metadata of the target type's display attributes (matched case-insensitively by name). */
+    attributes?: readonly CkAttributeInfo[];
+    /** Label of `true` (default "Yes"). */
+    yes?: string;
+    /** Label of `false` (default "No"). */
+    no?: string;
+    /** Locale of dates; the browser locale when omitted. */
+    locale?: string;
+}
+
+/** One candidate target of a reference field. Carries system properties only, never attributes. */
+interface EntityReferenceItem {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName?: string;
+    rtDisplayName?: string;
+    rtDisplayDescription?: string;
+    /** Label shown in the picker and stored as `displayName` in the field value. */
+    displayName: string;
+}
+/** Column labels of the reference picker dialog. */
+interface EntityReferenceColumnLabels {
+    name: string;
+    wellKnownName: string;
+    type: string;
+    rtId: string;
+}
+/**
+ * Secret-safe data source of `mm-entity-form-reference-field`, used both for the typeahead
+ * (`EntitySelectDataSource`) and for the grid dialog (`EntitySelectDialogDataSource`) of shared-ui
+ * `mm-entity-select-input`.
+ *
+ * It queries `entityFormGetReferenceOptions`, a document that selects **no `attributes` field at
+ * all**: only `rtId`, `ckTypeId`, `rtWellKnownName`, `rtDisplayName` and `rtDisplayDescription`.
+ * The target type's secrets therefore never reach the browser, unlike the octo-services
+ * `RuntimeEntitySelectDataSource` (its `getEntitiesByCkType` selects every attribute).
+ *
+ * Derived types of `targetCkTypeId` are included (`runtimeEntities(ckId)` is polymorphic), which is
+ * what a reference to a base type expects. Search matches `rtWellKnownName` and `rtDisplayName`.
+ */
+declare class EntityReferenceDataSource implements EntitySelectDataSource<EntityReferenceItem>, EntitySelectDialogDataSource<EntityReferenceItem> {
+    private readonly gql;
+    readonly targetCkTypeId: string;
+    readonly displayAttributes: readonly string[];
+    private readonly attributesGql?;
+    private readonly format;
+    private readonly columnLabels;
+    /**
+     * @param displayAttributes Non-secret target attributes shown next to the name (field
+     *   `referenceDisplayAttributes`). Non-empty → the options are read with
+     *   `entityFormGetReferenceOptionsWithAttributes` and exactly these `attributeNames` (plus the
+     *   non-secret `name`, which the plain document reads for the label as well).
+     * @param format CK metadata and labels used to format the display attribute values.
+     */
+    constructor(gql: EntityFormGetReferenceOptionsDtoGQL, targetCkTypeId: string, columnLabels?: Partial<EntityReferenceColumnLabels>, displayAttributes?: readonly string[], attributesGql?: EntityFormGetReferenceOptionsWithAttributesDtoGQL | undefined, format?: ReferenceDisplayFormat);
+    /** Variables of one page; exposed for tests (it is the complete request apart from the document). */
+    buildVariables(searchTerm: string | null, first: number, skip?: number): EntityFormGetReferenceOptionsQueryVariablesDto;
+    onFilter(filter: string, take?: number): Promise<EntitySelectResult<EntityReferenceItem>>;
+    getColumns(): ColumnDefinition[];
+    fetchData(options: DialogFetchOptions): Observable<DialogFetchResult<EntityReferenceItem>>;
+    onDisplayEntity(entity: EntityReferenceItem): string;
+    getIdEntity(entity: EntityReferenceItem): string;
+    /**
+     * The targets with the given rtIds, labelled like the picker rows (display attributes included).
+     * Used for the label of the current value; ids that cannot be read are missing from the map.
+     */
+    lookup(rtIds: readonly string[]): Promise<Map<string, EntityReferenceItem>>;
+    private fetchPage;
+    private request;
+}
+
+/** One selected reference target. The field value is always an array of these. */
+interface EntityFormReferenceValue$1 {
+    rtId: string;
+    ckTypeId: string;
+    displayName: string;
+}
+/**
+ * Reference editor of `mm-entity-form` (association roles and rtId-holding STRING attributes).
+ *
+ * - **Value:** `EntityFormReferenceValue[]` (`{ rtId, ckTypeId, displayName }`), an array even for
+ *   single selection; `[]` when nothing is selected.
+ * - **Limit:** with `multiple = false` a new pick replaces the current one, so the value never
+ *   grows beyond one entry; a written value with more entries is reported by the validator as
+ *   `{ maxItems: { max: 1, actual } }`. With `multiple = true` picks are appended, de-duplicated by
+ *   `rtId`.
+ * - **Picker:** shared-ui `mm-entity-select-input` (typeahead plus grid dialog) over the
+ *   secret-safe {@link EntityReferenceDataSource}, which selects only the non-secret `name` attribute of the targets.
+ * - **Display attributes:** with `displayAttributes` the picker rows and the current value read
+ *   `name · value1 · value2`, each value formatted by its CK value type (`displayAttributeInfo`):
+ *   enum names, yes/no, dates. The current value's label is looked up once per rtId; it only
+ *   changes what is shown, never the field value.
+ */
+declare class EntityFormReferenceFieldComponent implements ControlValueAccessor, Validator {
+    private readonly gql;
+    private readonly attributesGql;
+    readonly targetCkTypeId: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    /** Non-secret target attributes shown next to the name (AB#5547). */
+    readonly displayAttributes: _angular_core.InputSignal<readonly string[]>;
+    /** CK metadata of the display attributes on the target type; formats their values (AB#5547). */
+    readonly displayAttributeInfo: _angular_core.InputSignal<readonly CkAttributeInfo[]>;
+    readonly placeholder: _angular_core.InputSignal<string | null | undefined>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly messages: _angular_core.InputSignal<Partial<EntityFormsMessages>>;
+    protected readonly msg: _angular_core.Signal<EntityFormsMessages>;
+    protected readonly value: _angular_core.WritableSignal<EntityFormReferenceValue$1[]>;
+    private readonly disabledByForm;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Labels with display attributes, by rtId (from picks and from lookups of the current value). */
+    private readonly labels;
+    private readonly requested;
+    /** One data source per target type. */
+    readonly dataSource: _angular_core.Signal<EntityReferenceDataSource | null>;
+    constructor();
+    /** Label shown for a selected target: with display attributes when known, else its display name. */
+    labelOf(item: EntityFormReferenceValue$1): string;
+    private readonly selectInput;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    /** Current value (a copy). */
+    getValue(): EntityFormReferenceValue$1[];
+    writeValue(value: EntityFormReferenceValue$1[] | null | undefined): void;
+    registerOnChange(fn: (value: EntityFormReferenceValue$1[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    registerOnValidatorChange(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(_control: AbstractControl): ValidationErrors | null;
+    /** Applies picked entities: replaces in single mode (first pick wins), appends unique in multi mode. */
+    onPicked(items: (EntityReferenceItem | EntityFormReferenceValue$1)[] | null | undefined): void;
+    /** Removes one selected target. */
+    remove(rtId: string): void;
+    private lookupLabels;
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormReferenceFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityFormReferenceFieldComponent, "mm-entity-form-reference-field", never, { "targetCkTypeId": { "alias": "targetCkTypeId"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "displayAttributes": { "alias": "displayAttributes"; "required": false; "isSignal": true; }; "displayAttributeInfo": { "alias": "displayAttributeInfo"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Grid column of the records editor. */
+interface EntityFormRecordColumn {
+    path: string;
+    label: string;
+}
+/** Grid row: the stored dict plus its position (rows have no identity of their own). */
+interface GridRow {
+    index: number;
+    row: Record<string, unknown>;
+}
+/**
+ * Records editor of `mm-entity-form` for RECORD and RECORD_ARRAY attributes.
+ *
+ * - **Value:** `Record<string, unknown>[]`, one flat camelCase dict per record
+ *   (`{ key: 'a', order: 1 }`, the write shape of the value mapper). A single RECORD uses an array
+ *   of at most one entry (`single = true`); `[]` means "no record".
+ * - **Grid:** add / edit / move up / move down / remove. Edit and add open
+ *   `EntityFormRecordRowDialogComponent`, whose fields come from `EntityFormService.getCkRecord()`.
+ * - **Limits:** `single` disables "add" once one row exists. Nested RECORD / RECORD_ARRAY sub-fields
+ *   are read-only in the row dialog and their values are passed through unchanged.
+ */
+declare class EntityFormRecordsFieldComponent implements ControlValueAccessor {
+    private readonly entityFormService;
+    private readonly dialogService;
+    private readonly locale;
+    readonly ckRecordId: _angular_core.InputSignal<string>;
+    readonly columns: _angular_core.InputSignal<EntityFormRecordColumn[] | null | undefined>;
+    readonly single: _angular_core.InputSignal<boolean>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly messages: _angular_core.InputSignal<Partial<EntityFormsMessages>>;
+    /** No key ring (Q17): SECRET members cannot get a new value in the row editor (badge + hint only). */
+    readonly secretWritesDisabled: _angular_core.InputSignal<boolean>;
+    protected readonly icons: {
+        plus: _progress_kendo_svg_icons.SVGIcon;
+        edit: _progress_kendo_svg_icons.SVGIcon;
+        up: _progress_kendo_svg_icons.SVGIcon;
+        down: _progress_kendo_svg_icons.SVGIcon;
+        remove: _progress_kendo_svg_icons.SVGIcon;
+        view: _progress_kendo_svg_icons.SVGIcon;
+    };
+    /** Row name in the accessible names of the row buttons ("Remove row 2", AB#5579). */
+    protected rowLabel(index: number): string;
+    protected readonly msg: _angular_core.Signal<EntityFormsMessages>;
+    protected readonly rows: _angular_core.WritableSignal<Record<string, unknown>[]>;
+    private readonly disabledByForm;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** CK metadata of the record, loaded per `ckRecordId`; `null` until loaded or when unknown. */
+    readonly record: _angular_core.WritableSignal<CkRecordInfo | null>;
+    protected readonly gridRows: _angular_core.Signal<GridRow[]>;
+    readonly canAdd: _angular_core.Signal<boolean>;
+    /** Configured columns, or the first record attributes when the form lists none. */
+    readonly effectiveColumns: _angular_core.Signal<EntityFormRecordColumn[]>;
+    private readonly enumOptionsByAttribute;
+    /** Lower-cased names of SECRET members: their cells show the badge text, never a value. */
+    private readonly secretAttributes;
+    private onChange;
+    private onTouched;
+    private recordRequest;
+    constructor();
+    /** Current value (a shallow copy). */
+    getValue(): Record<string, unknown>[];
+    writeValue(value: Record<string, unknown>[] | Record<string, unknown> | null | undefined): void;
+    registerOnChange(fn: (value: Record<string, unknown>[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected cellText(row: Record<string, unknown>, path: string): string;
+    /** Opens the row dialog for a new row and appends the result. No-op when the limit is reached. */
+    addRow(): Promise<void>;
+    /** Opens the row dialog for an existing row; in read-only mode the dialog only displays it. */
+    editRow(index: number): Promise<void>;
+    removeRow(index: number): void;
+    moveUp(index: number): void;
+    moveDown(index: number): void;
+    /**
+     * Opens `EntityFormRecordRowDialogComponent` and resolves with the edited row, or `undefined` when
+     * cancelled. Protected seam so specs can stub the dialog.
+     */
+    protected openRowDialog(row: Record<string, unknown> | null): Promise<Record<string, unknown> | undefined>;
+    private swap;
+    private commit;
+    private loadRecord;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormRecordsFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityFormRecordsFieldComponent, "mm-entity-form-records-field", never, { "ckRecordId": { "alias": "ckRecordId"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "single": { "alias": "single"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "secretWritesDisabled": { "alias": "secretWritesDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Editor of a write-only secret field (AB#5542, AB#5544 item 4, decisions 2026-10-06 Q8/Q10/Q15/Q17).
+ *
+ * - The stored value is never shown or prefilled; the status badge lives in the field shell.
+ * - "Show" reveals only the value the user typed in this session (never a stored value); it is
+ *   disabled while the input is empty and resets when the input is emptied.
+ * - "Clear" stages removing an optional secret; the parent sends it on Save as
+ *   `clearSecretAttributes`. Clear and a new value are mutually exclusive: Clear is disabled while a
+ *   value is typed, and the input is replaced by a note with "Undo" while a clear is staged.
+ * - `multiline` renders a monospace text area (PEM keys, `EntityFormField.Editor: multiline`). It is
+ *   masked by rendering the text transparent (caret, selection and placeholder stay visible) and a
+ *   status line says how many lines were entered. This works in every browser — unlike
+ *   `-webkit-text-security`, which Firefox does not reliably support and which cannot keep line
+ *   breaks visible; an `<input type="password">` would drop the PEM line breaks.
+ * - The placeholder is also the input's tooltip, so it stays readable when a narrow panel (Data
+ *   Explorer peek) truncates it.
+ * - Read-only users get no editor at all (the badge is enough); without a key ring the input is
+ *   disabled and a hint explains why (`writesDisabled`, the parent disables the control).
+ */
+declare class EntityFormSecretEditorComponent {
+    readonly control: _angular_core.InputSignal<FormControl<unknown>>;
+    readonly messages: _angular_core.InputSignal<EntityFormsMessages>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly multiline: _angular_core.InputSignal<boolean>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Offer "Clear": optional SECRET with a stored value, edit mode, write access. */
+    readonly canClear: _angular_core.InputSignal<boolean>;
+    readonly clearStaged: _angular_core.InputSignal<boolean>;
+    /** No key ring (Q17): the input is disabled by the parent; this shows the hint. */
+    readonly writesDisabled: _angular_core.InputSignal<boolean>;
+    /** Change counter of the parent form, read so `hasTypedValue` follows the control value. */
+    readonly revision: _angular_core.InputSignal<number>;
+    readonly clearStagedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** The user asked to reveal the typed value. */
+    protected readonly shown: _angular_core.WritableSignal<boolean>;
+    protected readonly hasTypedValue: _angular_core.Signal<boolean>;
+    /** Only a typed value can be revealed; emptying the input masks it again. */
+    protected readonly revealed: _angular_core.Signal<boolean>;
+    /** Status line of a masked multiline value: the number of lines, never the content. */
+    protected readonly maskedStatus: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormSecretEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityFormSecretEditorComponent, "mm-entity-form-secret-editor", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "canClear": { "alias": "canClear"; "required": false; "isSignal": true; }; "clearStaged": { "alias": "clearStaged"; "required": false; "isSignal": true; }; "writesDisabled": { "alias": "writesDisabled"; "required": false; "isSignal": true; }; "revision": { "alias": "revision"; "required": false; "isSignal": true; }; }, { "clearStagedChange": "clearStagedChange"; }, never, never, true, never>;
+}
+
+type EntityFormGetListQueryDto = {
+    __typename?: 'OctoQuery';
+    runtime?: {
+        __typename?: 'RuntimeModelQuery';
+        runtimeEntities?: {
+            __typename?: 'RtEntityGenericDtoConnection';
+            totalCount?: number | null;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                endCursor?: string | null;
+                hasNextPage: boolean;
+            };
+            items?: Array<{
+                __typename?: 'RtEntity';
+                rtId: any;
+                ckTypeId: any;
+                rtWellKnownName?: string | null;
+                rtDisplayName: string;
+                rtCreationDateTime?: any | null;
+                rtChangedDateTime?: any | null;
+                attributes?: {
+                    __typename?: 'RtEntityAttributeDtoConnection';
+                    items?: Array<{
+                        __typename?: 'RtEntityAttribute';
+                        attributeName?: string | null;
+                        value?: any | null;
+                    } | null> | null;
+                } | null;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+
+/**
+ * One row of `<mm-entity-list>`. System properties keep their GraphQL names and every list
+ * attribute is flattened onto the row under its camelCase CK attribute name, so a Kendo column
+ * `field` equals the GraphQL `attributePath` and server-side sort / filter work unchanged.
+ */
+interface EntityListRow {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName: string | null;
+    rtDisplayName: string | null;
+    rtCreationDateTime: string | null;
+    rtChangedDateTime: string | null;
+    [attributeName: string]: unknown;
+}
+type ListItem = NonNullable<NonNullable<NonNullable<NonNullable<EntityFormGetListQueryDto['runtime']>['runtimeEntities']>['items']>[number]>;
+/**
+ * Attribute names the list may read for a resolved form: the `attribute` list columns, minus
+ * anything flagged secret. The resolver already drops secret columns; the second filter is a
+ * defensive guard so a resolver regression can never put a secret into the list query.
+ */
+declare function entityListAttributeNames(model: ResolvedEntityForm): string[];
+/** Whether the list shows derived types too (`includeDerivedTypes` or an abstract target type). */
+declare function entityListIncludesDerivedTypes(model: ResolvedEntityForm): boolean;
+/** Flattens a GraphQL list item into an {@link EntityListRow}. */
+declare function toEntityListRow(item: ListItem, fallbackCkTypeId: string): EntityListRow;
+/**
+ * Secret-safe `mm-list-view` data source of `<mm-entity-list>`.
+ *
+ * - Uses the package's own `entityFormGetList` document, whose `$attributeNames` is
+ *   `[String]!` — it always sends the explicit list of non-secret list-column attributes
+ *   (an omitted variable would make the server return every attribute, secrets included).
+ * - Restricts the query to the exact type with a `ckTypeId EQUALS` field filter unless the
+ *   form includes derived types or the type is abstract (`runtimeEntities(ckId)` returns
+ *   derived types by default).
+ */
+declare class EntityListDataSourceDirective extends OctoGraphQlDataSource<EntityListRow> {
+    private readonly listGQL;
+    private model;
+    private defaultSort;
+    constructor();
+    /**
+     * Sets the order used while the user has not sorted by a column (AB#5623). Refetches when the
+     * order changed and a model is set.
+     */
+    setDefaultSort(sort: readonly EntityListSortDescriptor[] | null | undefined): void;
+    /** The user's column sort, else the default sort, else `null` (server order). */
+    private effectiveSort;
+    /**
+     * Sets the resolved form and refetches from the first page. `defaultSort` (optional) replaces
+     * the order used while the user has not sorted by a column (see {@link setDefaultSort}).
+     */
+    setModel(model: ResolvedEntityForm | null, defaultSort?: readonly EntityListSortDescriptor[] | null): void;
+    /** The variables of the next list query (exposed for tests). */
+    buildVariables(options: FetchDataOptions): Record<string, unknown> | null;
+    fetchData(options: FetchDataOptions): Observable<FetchResultTyped<EntityListRow> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityListDataSourceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EntityListDataSourceDirective, "[mmEntityListDataSource]", ["mmEntityListDataSource"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Seeded placeholder values of NON-secret configuration attributes (AB#5623), e.g.
+ * `TODO_SET_AZURE_TENANT_ID`, that must read as "not configured" instead of as a real value.
+ *
+ * - A list `readonly string[]` applies to every attribute.
+ * - An object lists values `global`ly and/or per attribute (`attributes`, keyed by attribute name
+ *   in any casing: `azureTenantId`, `AzureTenantId`).
+ *
+ * Matching is exact and case-sensitive, on string values only.
+ */
+type EntityFormUnsetPlaceholderValues = readonly string[] | {
+    readonly global?: readonly string[];
+    readonly attributes?: Readonly<Record<string, readonly string[]>>;
+};
+/**
+ * Placeholder values of non-secret attributes that count as "not configured" (AB#5623). Analogous
+ * to `ENTITY_FORM_SECRET_PLACEHOLDER_VALUES`, but for plain configuration values:
+ *
+ * - **List** (`mm-entity-list`): a cell holding a placeholder shows the `notConfigured` message.
+ * - **Form** (`mm-entity-form`): the field starts empty with the `notConfigured` message as
+ *   placeholder hint; the value counts as unset (a required field is invalid, `VisibleWhen` sees no
+ *   value).
+ * - **Save**: the form never writes a placeholder back. An untouched placeholder field is not part
+ *   of the change set (the stored placeholder stays and keeps reading "not configured"); a typed
+ *   value replaces it; emptying the field again is "no change". A host that wants to remove the
+ *   placeholder from the store has to write `null` itself (e.g. in `beforeSave`).
+ *
+ * Never applies to secrets (SECRET decision, AB#5528: secret placeholders are dropped; a secret's
+ * state comes from `secretIsSet`): fields with `secret` (value type `SECRET`, CK `secret` metadata,
+ * the credential-name rule or a form decision) and attributes listed in `secretFields` are skipped,
+ * even when listed here.
+ *
+ * Optional; not provided = no placeholders (unchanged behaviour). The library ships no values.
+ */
+declare const ENTITY_FORM_UNSET_PLACEHOLDER_VALUES: InjectionToken<EntityFormUnsetPlaceholderValues>;
+/** Normalised lookup of {@link EntityFormUnsetPlaceholderValues}. */
+interface EntityFormUnsetPlaceholderLookup {
+    readonly global: ReadonlySet<string>;
+    /** Keyed by lower-case attribute name. */
+    readonly attributes: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/** Builds the lookup of a placeholder configuration (`null` / `undefined` = none). */
+declare function entityFormUnsetPlaceholderLookup(config: EntityFormUnsetPlaceholderValues | null | undefined): EntityFormUnsetPlaceholderLookup;
+/** What is known about the attribute a value belongs to. */
+interface EntityFormUnsetPlaceholderTarget {
+    attributeName: string;
+    valueType?: string | null;
+    /** The field / column is treated as a secret (any reason). */
+    secret?: boolean;
+}
+/**
+ * Whether `value` is a configured placeholder of the attribute. Always `false` for secrets
+ * (`secret` flag or value type `SECRET`) and for non-string values.
+ */
+declare function isEntityFormUnsetPlaceholder(lookup: EntityFormUnsetPlaceholderLookup, target: EntityFormUnsetPlaceholderTarget, value: unknown): boolean;
+/**
+ * Keys of the fields whose value in `values` (form values or `state.values`, keyed by field key)
+ * is an unset placeholder. Only non-secret attribute fields are considered.
+ */
+declare function entityFormUnsetPlaceholderFields(model: ResolvedEntityForm, values: Readonly<Record<string, unknown>> | null | undefined, lookup: EntityFormUnsetPlaceholderLookup): string[];
+
+/** Payload of {@link EntityListComponent.createRequested}: the concrete type to create. */
+interface EntityListCreateRequest {
+    ckTypeId: string;
+}
+/** Payload of {@link EntityListComponent.openRequested}. */
+interface EntityListOpenRequest {
+    rtId: string;
+    ckTypeId: string;
+}
+/**
+ * CSS classes of one list row (AB#5623), e.g. `{ 'row-disabled': row['enabled'] === false }`.
+ * Same shapes as Angular's `[ngClass]`; `null` / `undefined` = no class. The classes are set on the
+ * row's `<tr>` of the Kendo grid, so style them with global (or `::ng-deep`) CSS of the host.
+ */
+type EntityListRowClass = (row: EntityListRow) => string | string[] | Record<string, boolean> | null | undefined;
+/**
+ * App-wide default of {@link EntityListComponent.rowClass} (AB#5623). The input (and
+ * `mm-entity-page`'s `listRowClass` / route data `entityListRowClass`) wins.
+ */
+declare const ENTITY_LIST_ROW_CLASS: InjectionToken<EntityListRowClass>;
+/**
+ * Maps an {@link EntityListRowClass} onto `mm-list-view`'s `rowClass`. A throwing callback is
+ * logged and yields no class, so a host bug never breaks the list.
+ */
+declare function toListViewRowClass(rowClass: EntityListRowClass | null | undefined): RowClassFn | undefined;
+/** Labels of boolean list cells (default "Yes" / "No"). */
+interface EntityListCellLabels {
+    yes?: string;
+    no?: string;
+    /** Text of a cell holding an unset placeholder (AB#5623). Default "Not configured". */
+    notConfigured?: string;
+}
+/**
+ * How BOOLEAN list columns without an explicit `display` render (AB#5623): `'text'` (Yes / No,
+ * default) or `'icon'` (check / x icon named "<column>: Yes|No", filterable as boolean).
+ */
+type EntityListBooleanDisplay = 'text' | 'icon';
+/** Options of {@link toEntityListColumn}. */
+interface EntityListColumnOptions {
+    /** See {@link EntityListBooleanDisplay}. Default `'text'`. */
+    booleanDisplay?: EntityListBooleanDisplay;
+}
+/**
+ * Maps a resolved list column onto an `mm-list-view` column definition. Cells are formatted by the
+ * CK value type like the reference display of the form (AB#5547): ENUM → the enum value's name
+ * (the API returns the key), BOOLEAN → yes/no, dates → localized date and time.
+ */
+declare function toEntityListColumn(column: ResolvedListColumn, labels?: EntityListCellLabels, unsetPlaceholders?: EntityFormUnsetPlaceholderLookup, options?: EntityListColumnOptions): TableColumn;
+/**
+ * `<mm-entity-list>` — the list view of a resolved entity form.
+ *
+ * Columns come from the form's `ListColumns` (secret columns are never listed or queried).
+ * Row click and the "Edit"/"View" action emit {@link openRequested}; "New" emits
+ * {@link createRequested} — for an abstract type only after the user picked a concrete
+ * subtype. The context menu carries the Copy ID submenu (RtId / CkTypeId / RtCkTypeId /
+ * RtEntityId) and, when `canDelete && canWrite`, Delete with a confirmation.
+ *
+ * Host extensions (AB#5623): `toolbarActions` (after New), `rowActions` (icon buttons in the
+ * actions column after Edit/View), `rowMenuActions` (context menu between Copy ID and Delete) —
+ * plain `CommandItem`s as in `mm-list-view`; `onClick` receives the row (`EntityListRow`) as
+ * `e.data`. `rowClass` sets CSS classes per row (e.g. disabled rows). `defaultSort` (or the form's `listDefaultSort`) orders the list while the user has not
+ * sorted by a column; `labelResolver` translates column titles and enum texts.
+ *
+ * The component does not navigate; `<mm-entity-page>` (or the host) reacts to the outputs.
+ */
+declare class EntityListComponent {
+    private readonly confirmationService;
+    private readonly dangerConfirmation;
+    private readonly actionConfirmation;
+    private readonly notificationService;
+    private readonly dataService;
+    private readonly ckTypeSelectorDialog;
+    /** Resolves `EntityFormService` lazily: only the Type column needs the form titles. */
+    private readonly injector;
+    private readonly injectedLabelResolver;
+    private readonly injectedRowClass;
+    private readonly unsetPlaceholders;
+    /** Form titles per CK type (lower-case id) for the Type column (AB#5524). */
+    private readonly typeTitles;
+    private typeTitlesRequested;
+    /** The resolved form (`EntityFormService.resolve` / `resolveByFormKey`). */
+    readonly model: _angular_core.InputSignal<ResolvedEntityForm>;
+    /** Whether the current user may write (mapped from roles by the host). Default `true`. */
+    readonly canWrite: _angular_core.InputSignal<boolean>;
+    /** Partial message overrides; missing keys use the English defaults. */
+    readonly messages: _angular_core.InputSignal<Partial<EntityFormsMessages>>;
+    /** `mm-list-view` state persistence key; defaults to the route path. */
+    readonly listStateKey: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Appends a "Type" column with the display name of each row's CK type (lists over a base type):
+     * the title of the type's entity form, else the humanized type name (AB#5524).
+     */
+    readonly showTypeColumn: _angular_core.InputSignal<boolean>;
+    /**
+     * Order while the user has not sorted by a column (AB#5623). Wins over the form's
+     * `listDefaultSort`; `[]` = server order. A sort the user picked (also a remembered one from
+     * `listStateKey`) always wins. The column header shows no sort marker for the default order.
+     */
+    readonly defaultSort: _angular_core.InputSignal<readonly EntityListSortDescriptor[] | null | undefined>;
+    /** Translates column titles and enum texts (AB#5623); wins over `ENTITY_FORM_LABEL_RESOLVER`. */
+    readonly labelResolver: _angular_core.InputSignal<EntityFormLabelResolver | null | undefined>;
+    /** Host toolbar actions, shown after "New" (AB#5623). */
+    readonly toolbarActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /**
+     * Host row actions (AB#5623): icon buttons in the actions column after Edit / View. Set
+     * `svgIcon` and `text` (tooltip / aria-label); `onClick` gets the row as `e.data`.
+     */
+    readonly rowActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /** Host row menu entries (AB#5623): context menu, between Copy ID and Delete. */
+    readonly rowMenuActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /**
+     * CSS classes per row (AB#5623), e.g. to style disabled rows. Wins over `ENTITY_LIST_ROW_CLASS`;
+     * absent = no row classes (unchanged). See {@link EntityListRowClass}.
+     */
+    readonly rowClass: _angular_core.InputSignal<EntityListRowClass | null | undefined>;
+    /**
+     * How BOOLEAN columns without an explicit display render (AB#5623): `'text'` (Yes / No, default)
+     * or `'icon'` (check / x with an accessible name, boolean filter). A column's own
+     * `display: icon` always renders as icon.
+     */
+    readonly booleanDisplay: _angular_core.InputSignal<EntityListBooleanDisplay>;
+    /**
+     * Row field used as the row's human label (AB#5623): row action names ("Actions for <label>"),
+     * the delete confirmation target. A dotted path reads a nested value. Absent = today's
+     * behaviour (`name`, then `rtWellKnownName`, display name, `rtId`).
+     */
+    readonly rowLabelField: _angular_core.InputSignal<string | null | undefined>;
+    /** "New" was confirmed; carries the concrete type (after the subtype picker for abstract types). */
+    readonly createRequested: _angular_core.OutputEmitterRef<EntityListCreateRequest>;
+    /** A row was opened. */
+    readonly openRequested: _angular_core.OutputEmitterRef<EntityListOpenRequest>;
+    /** Entities were deleted. */
+    readonly deleted: _angular_core.OutputEmitterRef<EntityListOpenRequest[]>;
+    private readonly dataSource;
+    protected readonly msgs: _angular_core.Signal<EntityFormsMessages>;
+    protected readonly listViewMessages: _angular_core.Signal<{
+        searchPlaceholder: string;
+        noRecords: string;
+        booleanYes: string;
+        booleanNo: string;
+    }>;
+    protected readonly columns: _angular_core.Signal<TableColumn[]>;
+    protected readonly canCreate: _angular_core.Signal<boolean>;
+    protected readonly canDelete: _angular_core.Signal<boolean>;
+    protected readonly editable: _angular_core.Signal<boolean>;
+    /** Copy ID submenu (Studio convention, see the refinery-studio CLAUDE.md). */
+    readonly copyIdMenuItem: _angular_core.Signal<CommandItem>;
+    /**
+     * Context menu: Copy ID, the host's `rowMenuActions`, then (only with `canDelete && canWrite`)
+     * separator + Delete.
+     */
+    readonly contextMenuItems: _angular_core.Signal<CommandItem[]>;
+    /** Row action column: Edit (or View when read-only), then the host's `rowActions`. */
+    readonly actionItems: _angular_core.Signal<CommandItem[]>;
+    /** The `mm-list-view` row class callback (input, else the token, else none). */
+    protected readonly listViewRowClass: _angular_core.Signal<RowClassFn | undefined>;
+    /** Width of the actions column: Edit/View + the row menu, plus one icon button per host row action. */
+    protected readonly actionsColumnWidth: _angular_core.Signal<number>;
+    /** Toolbar: New (only with `canCreate && canWrite`), then the host's `toolbarActions`. */
+    readonly toolbarItems: _angular_core.Signal<CommandItem[]>;
+    /** The order used while the user has not sorted: the input, else the form's `listDefaultSort`. */
+    protected readonly effectiveDefaultSort: _angular_core.Signal<readonly EntityListSortDescriptor[]>;
+    constructor();
+    /** Loads the form titles of the Type column once; without them the type names are humanized. */
+    private loadTypeTitles;
+    /** Reloads the list. */
+    refresh(): void;
+    /**
+     * Starts "New". For an abstract type (`createRequiresSubtype`) the concrete-subtype picker
+     * opens first; cancelling it emits nothing.
+     */
+    requestCreate(): Promise<void>;
+    protected onRowClicked(rows: unknown[]): void;
+    private open;
+    private onDelete;
+    private copy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityListComponent, "mm-entity-list", never, { "model": { "alias": "model"; "required": true; "isSignal": true; }; "canWrite": { "alias": "canWrite"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "listStateKey": { "alias": "listStateKey"; "required": false; "isSignal": true; }; "showTypeColumn": { "alias": "showTypeColumn"; "required": false; "isSignal": true; }; "defaultSort": { "alias": "defaultSort"; "required": false; "isSignal": true; }; "labelResolver": { "alias": "labelResolver"; "required": false; "isSignal": true; }; "toolbarActions": { "alias": "toolbarActions"; "required": false; "isSignal": true; }; "rowActions": { "alias": "rowActions"; "required": false; "isSignal": true; }; "rowMenuActions": { "alias": "rowMenuActions"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; "booleanDisplay": { "alias": "booleanDisplay"; "required": false; "isSignal": true; }; "rowLabelField": { "alias": "rowLabelField"; "required": false; "isSignal": true; }; }, { "createRequested": "createRequested"; "openRequested": "openRequested"; "deleted": "deleted"; }, never, never, true, never>;
+}
+/**
+ * `System.Communication/SftpConfiguration` → `SFTP configuration`.
+ * @deprecated Use `humanizeCkTypeName` (or `ckTypeDisplayName` with form titles).
+ */
+declare function shortTypeName(ckTypeId: string): string;
+
+/** Template context of {@link EntityPageActionsDirective} (AB#5623). */
+interface EntityPageActionsContext {
+    /** The context object itself (`let-ctx`). */
+    $implicit: EntityPageActionsContext;
+    /** Which part of the page is shown. */
+    view: 'list' | 'form';
+    /** Form mode (`null` on the list). */
+    mode: EntityFormMode | null;
+    /** rtId of the open entity (`null` on the list and in create mode). */
+    rtId: string | null;
+    /** Runtime CK type of the open entity, else of the list. */
+    ckTypeId: string | null;
+    /** The resolved form of the open entity, else of the list. */
+    model: ResolvedEntityForm | null;
+    /** True while a save is running. */
+    saving: boolean;
+    /**
+     * The page (typed loosely to avoid a circular import): call `saveChanges()`, `patchFormValues()`
+     * or `refreshList()` on it, e.g. `(ctx.page as EntityPageComponent).patchFormValues({...})`.
+     */
+    page: unknown;
+}
+/**
+ * Host page actions of `<mm-entity-page>` (AB#5623): the template is rendered next to the page's
+ * own buttons — in the list header, and in the form's action bar (header or bottom bar, see
+ * `actionBarPosition`) before Cancel / Delete / Save.
+ *
+ * ```html
+ * <mm-entity-page formKey="form-company-profile">
+ *   <ng-template mmEntityPageActions let-ctx>
+ *     @if (ctx.view === 'form') {
+ *       <button kendoButton fillMode="flat" (click)="export(ctx.rtId)">Export</button>
+ *     }
+ *   </ng-template>
+ * </mm-entity-page>
+ * ```
+ */
+declare class EntityPageActionsDirective {
+    readonly templateRef: TemplateRef<EntityPageActionsContext>;
+    static ngTemplateContextGuard(_dir: EntityPageActionsDirective, _ctx: unknown): _ctx is EntityPageActionsContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityPageActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EntityPageActionsDirective, "ng-template[mmEntityPageActions]", never, {}, {}, never, never, true, never>;
+}
+
+/** Value of the `rtId` input / route parameter that opens the create form. */
+declare const ENTITY_PAGE_NEW = "new";
+/**
+ * Query parameter carrying the concrete runtime CK type of the entity to create or open
+ * (`new?type=…` after the subtype picker of an abstract type, `:rtId?type=…` for an entity of
+ * a derived type). Named `type`, not `ckTypeId`, so that `withComponentInputBinding` never
+ * binds it onto the page's `ckTypeId` input (the form's target type).
+ */
+declare const ENTITY_PAGE_TYPE_QUERY_PARAM = "type";
+/** Event of {@link EntityPageComponent.navigate}. */
+interface EntityPageNavigateEvent {
+    kind: 'list' | 'create' | 'edit';
+    rtId?: string;
+    ckTypeId?: string;
+}
+/** Event of {@link EntityPageComponent.saved}: an entity was created or updated. */
+interface EntityPageSavedEvent {
+    kind: 'create' | 'update';
+    rtId: string;
+    ckTypeId: string;
+}
+/** Event of {@link EntityPageComponent.deleted}. */
+interface EntityPageDeletedEvent {
+    rtId: string;
+    ckTypeId: string;
+}
+/** Which part of the page is shown. */
+type EntityPageView = 'loading' | 'list' | 'form' | 'error';
+/** Where the form's Save / Cancel / Delete buttons sit (AB#5623). */
+type EntityPageActionBarPosition = 'top' | 'bottom';
+/**
+ * How create / edit of a list row opens (AB#5623): `'page'` (navigate to the `new` / `:rtId`
+ * route, default) or `'dialog'` (a dialog over the list; the URL does not change).
+ */
+type EntityPageEditMode = 'page' | 'dialog';
+/**
+ * Prefill of the create form (AB#5623): the values, or a function of the concrete type to create
+ * (called once per create form; may return `null`).
+ */
+type EntityPageInitialValues = EntityFormPrefillValues | ((context: {
+    ckTypeId: string;
+}) => EntityFormPrefillValues | null | undefined);
+/**
+ * `<mm-entity-page>` — route component that combines `<mm-entity-list>` and `<mm-entity-form>`
+ * for one form (by `formKey`) or CK type (by `ckTypeId`).
+ *
+ * - No `rtId` → list (or, for a singleton form, the singleton entity directly).
+ * - `rtId === 'new'` → create form (`?type=` carries the concrete subtype of an abstract type).
+ * - any other `rtId` → edit form (or view form without write permission).
+ *
+ * Inputs can be bound by `withComponentInputBinding()` from route params / data; without it the
+ * page falls back to `ActivatedRoute` (params, data of this route and its parents, query params).
+ * Navigation is relative (`..`, `new`, `:rtId`), so it works under any mount point; set
+ * `routerNavigation` to `false` and handle {@link navigate} to drive it yourself.
+ *
+ * Host extensions (AB#5623, all optional, defaults = unchanged behaviour): `actionBarPosition`
+ * (Save / Cancel at the bottom), page actions via `<ng-template mmEntityPageActions>`, list
+ * `listToolbarActions` / `listRowActions` / `listRowMenuActions`, `defaultSort`, `labelResolver`
+ * (translated labels and enum texts), `initialValues` (create prefill),
+ * {@link patchFormValues} (prefill from a host action), `beforeSave` (normalise / veto the
+ * change set before it is saved), `listRowClass` (CSS classes per row) and `editMode: 'dialog'`
+ * (create / edit in a dialog over the list).
+ *
+ * Dialog mode (`editMode: 'dialog'`, AB#5623): "New", row click and Edit / View open the form in
+ * a Kendo dialog over the list instead of navigating. The same form, hooks and texts apply
+ * (`beforeSave`, `initialValues`, `labelResolver`, secrets, page actions with `view: 'form'`);
+ * actions sit in the dialog's bottom bar (page actions, Cancel, Delete, Save — Cancel left of the
+ * primary Save). Cancel, the close button and Escape ask before discarding unsaved changes; a
+ * route change while the dialog has changes goes through the unsaved-changes guard. After a save
+ * or delete the dialog closes and the list reloads; focus returns to the element that opened the
+ * dialog. No `navigate` events are emitted for dialog transitions. The `new` / `:rtId` routes keep
+ * working as pages (deep links); singleton forms always use the page.
+ */
+declare class EntityPageComponent implements HasUnsavedChanges {
+    private readonly route;
+    private readonly router;
+    private readonly formService;
+    private readonly dataService;
+    private readonly listGQL;
+    private readonly notificationService;
+    private readonly confirmationService;
+    private readonly actionConfirmation;
+    private readonly dangerConfirmation;
+    private readonly breadCrumbService;
+    private readonly injectedLabelResolver;
+    private readonly injectedBeforeSave;
+    /** Form key (`form-sftp-configuration` or `sftp-configuration`). Wins over `ckTypeId`. */
+    readonly formKey: _angular_core.InputSignal<string | undefined>;
+    /** Runtime CK type id of the form's target type (used when no `formKey` is given). */
+    readonly ckTypeId: _angular_core.InputSignal<string | undefined>;
+    /** Entity to edit; `'new'` opens the create form; absent shows the list. */
+    readonly rtId: _angular_core.InputSignal<string | undefined>;
+    /** Whether the user may write. Falls back to route data `canWrite`, then `true`. */
+    readonly canWrite: _angular_core.InputSignal<boolean | undefined>;
+    /** Partial message overrides; falls back to route data `messages`, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<EntityFormsMessages> | undefined>;
+    /** Perform the default relative Router navigation (in addition to emitting {@link navigate}). */
+    readonly routerNavigation: _angular_core.InputSignal<boolean>;
+    /**
+     * Where Save / Cancel / Delete sit on the form (AB#5623): `'top'` (header, default) or
+     * `'bottom'` (a bar below the form, right-aligned). Falls back to route data
+     * `entityPageActionBarPosition`.
+     */
+    readonly actionBarPosition: _angular_core.InputSignal<EntityPageActionBarPosition | undefined>;
+    /** Translates labels, titles and enum texts (AB#5623); wins over `ENTITY_FORM_LABEL_RESOLVER`. */
+    readonly labelResolver: _angular_core.InputSignal<EntityFormLabelResolver | null | undefined>;
+    /** List order while the user has not sorted (AB#5623). Falls back to route data `entityListDefaultSort`, then the form's `listDefaultSort`. */
+    readonly defaultSort: _angular_core.InputSignal<readonly EntityListSortDescriptor[] | null | undefined>;
+    /** Prefill of the create form (AB#5623). Falls back to route data `entityFormInitialValues`. */
+    readonly initialValues: _angular_core.InputSignal<EntityPageInitialValues | null | undefined>;
+    /**
+     * Hook run before every save (AB#5623): may modify the change set or veto the save. Wins over
+     * route data `entityFormBeforeSave` and `ENTITY_FORM_BEFORE_SAVE`. See {@link EntityFormBeforeSaveHook}.
+     */
+    readonly beforeSave: _angular_core.InputSignal<EntityFormBeforeSaveHook | null | undefined>;
+    /** Host toolbar actions of the list, after "New" (AB#5623). */
+    readonly listToolbarActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /** Host row actions of the list (icon buttons after Edit / View, AB#5623). */
+    readonly listRowActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /** Host row menu entries of the list (context menu, AB#5623). */
+    readonly listRowMenuActions: _angular_core.InputSignal<readonly CommandItem[]>;
+    /**
+     * How create / edit opens (AB#5623): `'page'` (default) or `'dialog'` (over the list). Falls back
+     * to route data `entityPageEditMode`. Ignored for singleton forms.
+     */
+    readonly editMode: _angular_core.InputSignal<EntityPageEditMode | undefined>;
+    /**
+     * CSS classes per list row (AB#5623), passed to `mm-entity-list`'s `rowClass`. Falls back to
+     * route data `entityListRowClass`, then `ENTITY_LIST_ROW_CLASS`.
+     */
+    readonly listRowClass: _angular_core.InputSignal<EntityListRowClass | null | undefined>;
+    /**
+     * How the list renders BOOLEAN columns (AB#5623), passed to `mm-entity-list`'s `booleanDisplay`:
+     * `'text'` (default) or `'icon'`. Falls back to route data `entityListBooleanDisplay`.
+     */
+    readonly listBooleanDisplay: _angular_core.InputSignal<EntityListBooleanDisplay | undefined>;
+    /**
+     * Field naming a row / entity for people (AB#5623): passed to `mm-entity-list`'s
+     * `rowLabelField` (row action names, delete confirmation) and used for the dialog / page title
+     * ("Edit <label>") and the delete confirmation of the open entity. Falls back to route data
+     * `entityListRowLabelField`; absent = today's behaviour (`name`, well-known name, display name, rtId).
+     */
+    readonly listRowLabelField: _angular_core.InputSignal<string | undefined>;
+    /** Emitted for every list / create / edit transition. */
+    readonly navigate: _angular_core.OutputEmitterRef<EntityPageNavigateEvent>;
+    /** Emitted after a successful create or update (not for "no changes"). Hosts refresh their lists on it. */
+    readonly saved: _angular_core.OutputEmitterRef<EntityPageSavedEvent>;
+    /** Emitted after the open entity was deleted from the form (before the navigation to the list). */
+    readonly deleted: _angular_core.OutputEmitterRef<EntityPageDeletedEvent>;
+    private readonly form;
+    /** Why Save / Create is disabled (e.g. a required secret without key ring, Q17), or `null`. */
+    protected readonly saveBlockedReason: _angular_core.Signal<string | null>;
+    private readonly list;
+    private readonly listElement;
+    /** Host page actions (`<ng-template mmEntityPageActions>`, AB#5623). */
+    protected readonly pageActions: _angular_core.Signal<EntityPageActionsDirective | undefined>;
+    private readonly paramMap;
+    private readonly queryParamMap;
+    private readonly routeData;
+    protected readonly view: _angular_core.WritableSignal<EntityPageView>;
+    protected readonly errorMessage: _angular_core.WritableSignal<string | null>;
+    /** The form resolved for the page's type (list + breadcrumb title). */
+    protected readonly baseModel: _angular_core.WritableSignal<ResolvedEntityForm | null>;
+    /** The form resolved for the entity's concrete type (create / edit). */
+    protected readonly formModel: _angular_core.WritableSignal<ResolvedEntityForm | null>;
+    protected readonly mode: _angular_core.WritableSignal<EntityFormMode>;
+    protected readonly state: _angular_core.WritableSignal<EntityFormValueState | undefined>;
+    protected readonly entityRtId: _angular_core.WritableSignal<string | null>;
+    protected readonly entityCkTypeId: _angular_core.WritableSignal<string | null>;
+    protected readonly entityName: _angular_core.WritableSignal<string | null>;
+    protected readonly saving: _angular_core.WritableSignal<boolean>;
+    /** Record metadata of the form's type (type conversion of record sub-values in the form). */
+    protected readonly records: _angular_core.WritableSignal<Record<string, CkRecordInfo>>;
+    /** Well-known name forced onto a singleton that is created on first save. */
+    protected readonly singletonWellKnownName: _angular_core.WritableSignal<string | null>;
+    /** The create / edit dialog over the list is shown (`editMode: 'dialog'`, AB#5623). */
+    protected readonly dialogOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly saveIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly backIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly deleteIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly msgs: _angular_core.Signal<EntityFormsMessages>;
+    protected readonly effectiveCanWrite: _angular_core.Signal<boolean>;
+    protected readonly effectiveLabelResolver: _angular_core.Signal<EntityFormLabelResolver | null>;
+    /** The effective before-save hook: input, else route data `entityFormBeforeSave`, else the token. */
+    private effectiveBeforeSave;
+    /** `'dialog'` only for non-singleton forms with `editMode` (input, else route data) `'dialog'`. */
+    protected readonly effectiveEditMode: _angular_core.Signal<EntityPageEditMode>;
+    protected readonly effectiveActionBarPosition: _angular_core.Signal<EntityPageActionBarPosition>;
+    /** `undefined` = no page-level default (the list falls back to the form's `listDefaultSort`). */
+    protected readonly effectiveDefaultSort: _angular_core.Signal<readonly EntityListSortDescriptor[] | undefined>;
+    /** The list's row class callback: input, else route data `entityListRowClass` (else the list's token). */
+    protected readonly effectiveListRowClass: _angular_core.Signal<EntityListRowClass | undefined>;
+    /** Row label field: input, else route data `entityListRowLabelField`, else none (default naming). */
+    protected readonly effectiveRowLabelField: _angular_core.Signal<string | undefined>;
+    /** Boolean columns of the list: input, else route data `entityListBooleanDisplay`, else text. */
+    protected readonly effectiveListBooleanDisplay: _angular_core.Signal<EntityListBooleanDisplay>;
+    /** The prefill of the current create form (AB#5623), computed when the form opens. */
+    protected readonly createInitialValues: _angular_core.WritableSignal<Readonly<Record<string, unknown>> | null>;
+    /** Base model with translated title / description (list header). */
+    protected readonly localizedBase: _angular_core.Signal<ResolvedEntityForm | null>;
+    /**
+     * Breadcrumb labels (`{{entityFormTitle}}` / `{{entityName}}`), derived from the page state so
+     * they follow a language change of the label resolver or the messages (AB#5623). `null` while
+     * nothing is resolved.
+     */
+    protected readonly breadcrumbLabels: _angular_core.Signal<Record<string, string> | null>;
+    /** Context of the host page actions template. */
+    protected readonly actionsContext: _angular_core.Signal<EntityPageActionsContext>;
+    /** Context of the host page actions in the create / edit dialog (always the form view). */
+    protected readonly dialogActionsContext: _angular_core.Signal<EntityPageActionsContext>;
+    private buildActionsContext;
+    protected readonly isSingleton: _angular_core.Signal<boolean>;
+    /** Host heading override (`entityListTitle` route data), else the resolved form title. */
+    protected readonly listTitle: _angular_core.Signal<string>;
+    /** `entityListTypeColumn` route data: show the row's CK type in the list. */
+    protected readonly showTypeColumn: _angular_core.Signal<boolean>;
+    protected readonly readOnly: _angular_core.Signal<boolean>;
+    protected readonly canDeleteEntity: _angular_core.Signal<boolean>;
+    protected readonly title: _angular_core.Signal<string>;
+    /** The effective navigation context (inputs win over the route). */
+    private readonly context;
+    private loadToken;
+    private suppressGuard;
+    /** Where the next loaded form is shown: the page, or the dialog over the list. */
+    private formTarget;
+    /** Element focused when the dialog opened; focused again when it closes. */
+    private dialogTrigger;
+    constructor();
+    hasUnsavedChanges(): boolean;
+    unsavedChangesMessages(): UnsavedChangesMessages;
+    /**
+     * Validates and saves the form. Creates the entity in create mode (then switches to its edit
+     * route), updates only the changed attributes in edit mode. Resolves `false` when the form is
+     * invalid or the server rejected the change.
+     */
+    saveChanges(): Promise<boolean>;
+    protected onSave(): Promise<void>;
+    protected onBack(): Promise<void>;
+    protected onCreateRequested(event: EntityListCreateRequest): Promise<void>;
+    protected onOpenRequested(event: EntityListOpenRequest): Promise<void>;
+    /** Cancel, the dialog's close button and Escape: asks before discarding unsaved changes. */
+    protected onDialogCancel(): Promise<void>;
+    protected onDelete(): Promise<void>;
+    private load;
+    private openCreate;
+    private openSingleton;
+    private startCreate;
+    /**
+     * Loads an entity into the form. When the entity turns out to be of a different (derived)
+     * type than the model, the form for that type is resolved and the values are read again with
+     * its attribute list. Resolves `false` when the entity does not exist.
+     */
+    private openEntity;
+    private applyLoaded;
+    private recordsFor;
+    private modelForType;
+    /** rtId of the first entity of the type (singleton forms without a well-known name). */
+    private firstEntityRtId;
+    private resetEntity;
+    private fail;
+    /** Shows the loaded form: on the page, or in the dialog over the list. */
+    private showForm;
+    /** Loads the create / edit form into the dialog over the list. */
+    private openDialog;
+    /**
+     * Closes the dialog without asking, optionally reloads the list, and gives the focus back to
+     * the element that opened the dialog (or the list when that element is gone).
+     */
+    private closeDialog;
+    private go;
+    /** Reads a route data key from this route or the nearest ancestor that defines it. */
+    private inheritedData;
+    /** Reloads the list (when the list is shown). */
+    refreshList(): void;
+    /**
+     * Sets values of the open form from the host (AB#5623), e.g. a "Prefill from user" page action.
+     * See `EntityFormComponent.patchValues`: the values always count as user edits (the form gets
+     * dirty, the unsaved-changes guard applies and Save sends them); secret and read-only fields are
+     * skipped. Returns the field keys that were set (`[]` when no writable form is shown).
+     */
+    patchFormValues(values: EntityFormPrefillValues): string[];
+    /** Translated title of a model (AB#5623). */
+    private formTitle;
+    /** The host prefill for a create form of the given type. */
+    private initialValuesFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityPageComponent, "mm-entity-page", never, { "formKey": { "alias": "formKey"; "required": false; "isSignal": true; }; "ckTypeId": { "alias": "ckTypeId"; "required": false; "isSignal": true; }; "rtId": { "alias": "rtId"; "required": false; "isSignal": true; }; "canWrite": { "alias": "canWrite"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "routerNavigation": { "alias": "routerNavigation"; "required": false; "isSignal": true; }; "actionBarPosition": { "alias": "actionBarPosition"; "required": false; "isSignal": true; }; "labelResolver": { "alias": "labelResolver"; "required": false; "isSignal": true; }; "defaultSort": { "alias": "defaultSort"; "required": false; "isSignal": true; }; "initialValues": { "alias": "initialValues"; "required": false; "isSignal": true; }; "beforeSave": { "alias": "beforeSave"; "required": false; "isSignal": true; }; "listToolbarActions": { "alias": "listToolbarActions"; "required": false; "isSignal": true; }; "listRowActions": { "alias": "listRowActions"; "required": false; "isSignal": true; }; "listRowMenuActions": { "alias": "listRowMenuActions"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "listRowClass": { "alias": "listRowClass"; "required": false; "isSignal": true; }; "listBooleanDisplay": { "alias": "listBooleanDisplay"; "required": false; "isSignal": true; }; "listRowLabelField": { "alias": "listRowLabelField"; "required": false; "isSignal": true; }; }, { "navigate": "navigate"; "saved": "saved"; "deleted": "deleted"; }, ["pageActions"], never, true, never>;
+}
+
+/**
+ * Options of {@link entityFormRoutes}.
+ *
+ * Route parameter contract (stable, relied upon by the Refinery Studio, AB#5523):
+ *
+ * | Path      | Page state                                                          |
+ * |-----------|---------------------------------------------------------------------|
+ * | `''`      | list (a singleton form opens its entity directly)                   |
+ * | `new`     | create form; `?type=<rtCkTypeId>` = concrete type (abstract forms)   |
+ * | `:rtId`   | edit form (view form without write permission); optional `?type=`   |
+ *
+ * Route `data` carries `formKey` / `ckTypeId` / `canWrite` / `messages` (bound to the page
+ * inputs by `withComponentInputBinding()`, read from `ActivatedRoute` otherwise), the `new`
+ * route additionally `rtId: 'new'`, and the `breadcrumb` items with the `{{entityFormTitle}}` /
+ * `{{entityName}}` labels the page fills via `BreadCrumbService.updateBreadcrumbLabels`.
+ */
+interface EntityFormRoutesOptions {
+    /** Form key (`form-sftp-configuration` or `sftp-configuration`). Wins over `ckTypeId`. */
+    formKey?: string;
+    /** Runtime CK type id of the target type, used when no `formKey` is given. */
+    ckTypeId?: string;
+    /**
+     * Write permission for every user who can reach the routes. Hosts with role-dependent
+     * permissions bind `canWrite` on their own wrapper or pass it as route data of a parent.
+     */
+    canWrite?: boolean;
+    /** Message overrides passed to the page. */
+    messages?: Partial<EntityFormsMessages>;
+    /**
+     * Breadcrumb URL of the list (relative to the host's breadcrumb root, e.g.
+     * `communication/sftp`). Without it no breadcrumb items are added.
+     */
+    breadcrumbUrl?: string;
+    /** Label of the list breadcrumb. Default `{{entityFormTitle}}` (the resolved form title). */
+    breadcrumbLabel?: string;
+    /**
+     * Heading of the list (and of the singleton form) instead of the resolved form's title — e.g.
+     * "All configurations" for a generic list over a base type whose `form-default` title would be
+     * the type name. Route data key `entityListTitle`.
+     */
+    title?: string;
+    /**
+     * Adds a "Type" column (short CK type name of each row) to the list — for lists over a base type
+     * with derived types. Route data key `entityListTypeColumn`.
+     */
+    showTypeColumn?: boolean;
+    /**
+     * Order of the list while the user has not sorted by a column (AB#5623). Wins over the form's
+     * `listDefaultSort`. Route data key `entityListDefaultSort`.
+     */
+    defaultSort?: EntityListSortDescriptor[];
+    /**
+     * Where the form's Save / Cancel / Delete buttons sit (AB#5623): `'top'` (header, default) or
+     * `'bottom'` (bar below the form). Route data key `entityPageActionBarPosition`.
+     */
+    actionBarPosition?: 'top' | 'bottom';
+    /** Prefill of the create form (AB#5623). Route data key `entityFormInitialValues`. */
+    initialValues?: EntityFormPrefillValues;
+    /**
+     * Hook run before every save (AB#5623): normalise / derive values or veto the save. Route data
+     * key `entityFormBeforeSave`. See `EntityFormBeforeSaveHook`.
+     */
+    beforeSave?: EntityFormBeforeSaveHook;
+    /**
+     * CSS classes per list row (AB#5623), e.g. to style disabled rows. Route data key
+     * `entityListRowClass`. See `EntityListRowClass`.
+     */
+    rowClass?: EntityListRowClass;
+    /**
+     * `'dialog'` opens create / edit of a list row in a dialog over the list instead of navigating
+     * to `new` / `:rtId` (AB#5623; those routes still work as pages). Default `'page'`. Route data
+     * key `entityPageEditMode`.
+     */
+    editMode?: 'page' | 'dialog';
+    /**
+     * `'icon'` renders the list's BOOLEAN columns as check / x icons (AB#5623). Default `'text'`.
+     * Route data key `entityListBooleanDisplay`.
+     */
+    booleanDisplay?: 'text' | 'icon';
+    /**
+     * Field naming a row / entity for people (AB#5623): row action names, dialog / page title and
+     * delete confirmations. Route data key `entityListRowLabelField`.
+     */
+    rowLabelField?: string;
+    /** Label of the create breadcrumb. Default `New`. */
+    newBreadcrumbLabel?: string;
+    /** Label of the edit breadcrumb. Default `{{entityName}}`. */
+    entityBreadcrumbLabel?: string;
+    /** Icon of the list breadcrumb. */
+    svgIcon?: SVGIcon;
+    /** Additional route data merged into all three routes (e.g. `roles`). */
+    data?: Record<string, unknown>;
+}
+/**
+ * Builds the three child routes of an entity form page: `''` (list), `new` (create) and
+ * `:rtId` (edit), each rendering `EntityPageComponent` lazily and guarded by
+ * `UnsavedChangesGuard`. Mount them under any path:
+ *
+ * ```ts
+ * { path: 'sftp', children: entityFormRoutes({ formKey: 'sftp-configuration', breadcrumbUrl: 'communication/sftp' }) }
+ * ```
+ */
+declare function entityFormRoutes(opts?: EntityFormRoutesOptions): Routes;
+
+/** Minimal shape of an `RtEntity` row as returned by `entityFormGetEntityForms`. */
+interface RawRtEntityRow {
+    rtId: string;
+    rtWellKnownName?: string | null;
+    ckTypeId?: string | null;
+    attributes?: {
+        items?: ({
+            attributeName?: string | null;
+            value?: unknown;
+        } | null)[] | null;
+    } | null;
+}
+/**
+ * Parses one `System.UI/EntityForm` row of the generic runtime API into an
+ * {@link EntityFormDefinition}. Returns `null` when the row has no `TargetCkTypeId`.
+ * Absent optionals stay `undefined`; explicit `null` values from the server are kept as `null`.
+ */
+declare function parseEntityForm(row: RawRtEntityRow): EntityFormDefinition | null;
+/** Parses every row; rows without a target type are dropped. */
+declare function parseEntityForms(rows: readonly (RawRtEntityRow | null | undefined)[] | null | undefined): EntityFormDefinition[];
+
+/** Section key of the implicit section used when a form declares no sections. */
+declare const DEFAULT_SECTION_KEY = "__default";
+/** Section key of the section holding generated (unmentioned) attributes. */
+declare const GENERATED_SECTION_KEY = "__generated";
+/** Default title of the generated section. */
+declare const DEFAULT_GENERATED_SECTION_TITLE = "Further attributes";
+type EntityFormSource = 'tenant' | 'seeded';
+interface ResolveEntityFormOptions {
+    /** Record metadata keyed by versioned ckRecordId (CkAttributeInfo.ckRecordId). */
+    records?: Record<string, CkRecordInfo>;
+}
+/**
+ * Picks the form for a type. Exact-target forms win; otherwise the nearest ancestor that has
+ * forms with `includeDerivedTypes` supplies the candidates. Candidates are ordered tenant before
+ * seeded, then priority descending, then rtWellKnownName/rtId ascending. Forms are never merged.
+ */
+declare function pickEntityForm(type: CkTypeInfo, forms: readonly EntityFormDefinition[]): {
+    form: EntityFormDefinition;
+    source: EntityFormSource;
+} | null;
+/** Editor chosen when the form says `auto`, nothing, or something unknown. */
+declare function autoEditorFor(valueType: string | null | undefined): EntityFormEditor;
+/** True when an explicit editor can edit the given value type. */
+declare function isEditorCompatible(editor: EntityFormEditor, valueType: string | null | undefined): boolean;
+/**
+ * Form control key of an association field: `assoc:<rtRoleId>` with `.` replaced by `_` —
+ * Angular FormGroup keys must not contain `.` ("FormGroup keys cannot include '.'" for role ids
+ * such as `System.Communication/Manages`, visual check 2026-10-06). The key is only an id; the
+ * role itself travels on `ResolvedField.association`.
+ */
+declare function associationFieldKey(rtRoleId: string): string;
+/**
+ * The default list order of a form (AB#5623): `listDefaultSort` canonicalised against the type.
+ * Unknown paths, secrets and record attributes are dropped (with a warning); `rtId` sorts by id.
+ */
+declare function resolveListDefaultSort(form: EntityFormDefinition, type: CkTypeInfo, secretNames: ReadonlySet<string>, warnings?: string[]): EntityListSortDescriptor[];
+/**
+ * Resolves the form for a type: picks it ({@link pickEntityForm}), falls back to
+ * {@link BUILT_IN_DEFAULT_FORM} (`source: 'builtIn'`, with a warning), and matches every field
+ * against the CK metadata. See plan §2.2 for the normative rules; they are implemented here
+ * in the order they are listed there.
+ */
+declare function resolveEntityForm(type: CkTypeInfo, forms: readonly EntityFormDefinition[], opts?: ResolveEntityFormOptions): ResolvedEntityForm;
+
+/**
+ * URL key of a form (`sftp-configuration`), accepted by `EntityFormService.resolveByFormKey`:
+ * the well-known name without the `form-` prefix, otherwise the kebab-cased target type name.
+ * The well-known name wins because the kebab form of some type names differs from the seeded
+ * name (`EMailSenderConfiguration` → `e-mail-sender-configuration`, seeded as
+ * `form-email-sender-configuration`).
+ */
+declare function entityFormKey(form: Pick<EntityFormDefinition, 'rtWellKnownName' | 'targetCkTypeId'>): string;
+/** One entry of {@link entityFormCatalog}: the effective form of one target type. */
+interface EntityFormCatalogEntry {
+    /** URL key (see {@link entityFormKey}); stable per target type. */
+    key: string;
+    /** Settings category key (`connections`, `ai`, …), lower case. */
+    category: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    targetCkTypeId: string;
+    includeDerivedTypes: boolean;
+    singleton: boolean;
+    /** The form that wins for the target type (tenant form before seeded, then priority). */
+    form: EntityFormDefinition;
+}
+/**
+ * The forms that belong in a settings overview (concept §5.6): one entry per target type whose
+ * effective form has a `Category`. The effective form is picked like the resolver does for an
+ * exact type match (tenant form first, then higher priority, then well-known name), so a tenant
+ * override replaces the delivered entry — and can also move it to another category or remove it
+ * from the overview by leaving `Category` empty. The key prefers a delivered `form-*` name of
+ * the type, so URLs stay stable when a tenant form is added. Sorted by title.
+ */
+declare function entityFormCatalog(forms: readonly EntityFormDefinition[]): EntityFormCatalogEntry[];
+/**
+ * Display names of CK types from the forms (AB#5524): per target type (lower-case key) the
+ * `Name` of its effective form (tenant form first, then priority), for every form with a name —
+ * also forms without `Category`. CK types carry no display name of their own.
+ */
+declare function entityFormTypeTitles(forms: readonly EntityFormDefinition[]): Map<string, string>;
+/**
+ * Display name of a CK type: the form title of {@link entityFormTypeTitles} when there is one,
+ * else {@link humanizeCkTypeName} (`FinApiConfiguration` → `finAPI configuration`).
+ */
+declare function ckTypeDisplayName(ckTypeId: string, titles?: ReadonlyMap<string, string>): string;
+
+/**
+ * Human-readable names of CK types (AB#5524): `System.Communication/EMailReceiverConfiguration-1`
+ * → `E-mail receiver configuration`, `…/FinApiConfiguration` → `finAPI configuration`.
+ *
+ * CK types carry no display name, so a name is derived from the type name: PascalCase is split
+ * into words in sentence case, and known acronyms / brand names keep their spelling.
+ */
+/** `System.Communication/SftpConfiguration-1` → `SftpConfiguration` (no model, no version). */
+declare function ckTypeShortName(ckTypeId: string): string;
+/**
+ * Human-readable name of a CK type id or type name, in sentence case with known acronyms and
+ * brand names (`SAP`, `SFTP`, `AI`, `EDA`, `E-mail`, `finAPI`, `weclapp`, …). Returns the input
+ * when it holds no name.
+ */
+declare function humanizeCkTypeName(ckTypeIdOrName: string): string;
+
+/**
+ * Built-in copy of the seeded `form-default` (platform-services
+ * `SystemUiCkModel/Blueprints/System.UI.EntityForms/seed-data/entities.yaml`, rtId
+ * 670300000000000000000001), transcribed field by field.
+ *
+ * Used when a tenant has no applicable form at all: System.UI < 2.7.0 (no EntityForm type), the
+ * forms query failed, or `form-default` was deleted. Keep it in step with the seed; a spec asserts
+ * that it resolves exactly like the parsed seed entity.
+ */
+declare const BUILT_IN_DEFAULT_FORM: EntityFormDefinition;
+
+/**
+ * Host-provided built-in forms (AB#5524). Each one stands in for a delivered form of its target
+ * type **only where the normal resolution would end at the chain end** (`form-default` on
+ * `System/Entity`, or no form at all) — e.g. before a new version of the seeding blueprint has
+ * been rolled out. A tenant or seeded form for the exact type, or for an ancestor with
+ * `IncludeDerivedTypes`, always wins over a fallback. Same idea as the built-in `form-default`
+ * safety net (concept §5.3 step 4), but per type and owned by the host.
+ *
+ * Provide them at root with this token, or — to keep the entry point out of the initial bundle —
+ * with `provideEntityFormFallbacks(forms)` on lazy routes (registers them in the root
+ * `EntityFormService`, one cache).
+ *
+ * Use the delivered form's `rtWellKnownName` (`form-sap-configuration`) so URL keys stay the same
+ * when the seeded form arrives, set `isTenantForm: false` and leave `rtId` empty. As soon as any
+ * form (tenant or seeded) targets the type, the fallback is ignored — a tenant can therefore hide
+ * a fallback entry from a settings overview by creating a form without `Category`.
+ */
+declare const ENTITY_FORM_FALLBACK_FORMS: InjectionToken<readonly EntityFormDefinition[]>;
+/**
+ * The loaded forms plus every fallback whose target type no loaded form targets (exact type,
+ * case-insensitive). Later fallbacks for an already covered type are dropped as well.
+ */
+declare function withFallbackForms(loaded: readonly EntityFormDefinition[], fallbacks: readonly EntityFormDefinition[] | null | undefined): EntityFormDefinition[];
+/** The end of the resolution chain: a form on `System/Entity` (the seeded or built-in `form-default`). */
+declare function isChainEndForm(form: Pick<EntityFormDefinition, 'targetCkTypeId'>): boolean;
+/**
+ * The fallbacks that apply on top of the loaded forms: per target type (first fallback wins),
+ * only when the type exists (`typeOf` returns its CK metadata) and `pickEntityForm(type, loaded)`
+ * finds nothing or only the chain end. Fallbacks for a type without metadata are dropped, so a
+ * tenant without that model gets no Settings entry for it.
+ */
+declare function selectFallbackForms(loaded: readonly EntityFormDefinition[], fallbacks: readonly EntityFormDefinition[] | null | undefined, typeOf: (rtCkTypeId: string) => CkTypeInfo | null | undefined): EntityFormDefinition[];
+
+/** A destructive action the entity form components are about to run (AB#5524). */
+interface EntityFormActionRequest {
+    action: 'delete';
+    /** Runtime CK type id of the (first) affected entity. */
+    ckTypeId: string;
+    /** Number of affected entities. */
+    count: number;
+    /** Short English description, e.g. `delete 2 entities`. */
+    description: string;
+}
+/**
+ * Optional host hook asked **before** the component's own danger confirmation of a destructive
+ * action — e.g. the Refinery Studio's production-mode check (`TenantModeService
+ * .confirmProductionAction`), which the former configuration list ran before deleting. Resolve
+ * `false` to cancel. Provide it on the route (or root) injector of the pages that render
+ * `mm-entity-list` / `mm-entity-page`.
+ */
+type EntityFormActionConfirmation = (request: EntityFormActionRequest) => Promise<boolean>;
+declare const ENTITY_FORM_ACTION_CONFIRMATION: InjectionToken<EntityFormActionConfirmation>;
+/** Runs the host hook (absent = allowed); a throwing hook cancels the action. */
+declare function confirmEntityFormAction(hook: EntityFormActionConfirmation | null | undefined, request: EntityFormActionRequest): Promise<boolean>;
+/**
+ * Optional host replacement of the components' own danger confirmation (AB#5579). By default
+ * `mm-entity-list` / `mm-entity-page` ask `ConfirmationService.showDangerConfirm(options)`; a host
+ * that adds environment knowledge (e.g. the Refinery Studio's `DangerConfirmService`: production =
+ * type the name) provides this token instead and then usually needs no
+ * {@link ENTITY_FORM_ACTION_CONFIRMATION} for deletes. Resolve `false` to cancel.
+ */
+type EntityFormDangerConfirmation = (options: DangerConfirmationOptions, request: EntityFormActionRequest) => Promise<boolean>;
+declare const ENTITY_FORM_DANGER_CONFIRMATION: InjectionToken<EntityFormDangerConfirmation>;
+/**
+ * The danger confirmation of an entity delete (AB#5579): the title names the entity (or the
+ * count), `confirmText` = verb + object, texts from {@link EntityFormsMessages}.
+ */
+declare function entityDeleteConfirmation(messages: EntityFormsMessages, names: readonly string[]): DangerConfirmationOptions;
+/** Asks the host replacement (when provided) or `ConfirmationService.showDangerConfirm`; errors cancel. */
+declare function confirmEntityFormDanger(hook: EntityFormDangerConfirmation | null | undefined, confirmation: ConfirmationService, options: DangerConfirmationOptions, request: EntityFormActionRequest): Promise<boolean>;
+
+/**
+ * Whether secrets can be written in this environment (decision Q17, AB#5544): `false` when the
+ * environment has no key ring (`SecretEnvironmentStatusDto.keyRingConfigured`, bot services
+ * `GET {tenantId}/v1/secrets/status`). Then every secret input of `mm-entity-form` is disabled with
+ * a hint instead of failing late on save (`SecretEncryptionNotConfigured`).
+ *
+ * Optional: without a provider (or while the signal is `null` / `undefined`) secrets are writable.
+ * The host provides it from its status client, e.g.
+ * `{ provide: ENTITY_FORM_SECRET_KEY_RING_CONFIGURED, useFactory: () => statusService.keyRingConfigured }`.
+ */
+declare const ENTITY_FORM_SECRET_KEY_RING_CONFIGURED: InjectionToken<Signal<boolean | null | undefined>>;
+/**
+ * Values that count as "not set" for LEGACY secret fields (AB#5623): plain `STRING` attributes
+ * treated as secrets by form decision, CK metadata or the credential-name rule. Their presence is
+ * probed with field filters (`IS_NOT_NULL` and `NOT_EQUALS ''`); each value listed here adds a
+ * `NOT_EQUALS <value>` filter, so a seeded placeholder (exact, case-sensitive match) reads
+ * "Not set" instead of "Set".
+ *
+ * Optional; not provided = only `null` and `''` count as not set (unchanged behaviour). The
+ * library ships no placeholder values of its own — the host lists the ones its seed data uses.
+ * It has no effect on attributes of value type `SECRET` (AB#5528): their state comes from the
+ * server (`secretIsSet`), which is the reliable way — migrate secrets to `SECRET` where possible.
+ */
+declare const ENTITY_FORM_SECRET_PLACEHOLDER_VALUES: InjectionToken<readonly string[]>;
+
+/**
+ * Entity system properties that a form may reference by AttributePath. They are not CK
+ * attributes: `rtWellKnownName` is written through `RtEntityInput.rtWellKnownName`, the two
+ * timestamps are engine-stamped and always read-only.
+ */
+declare const SYSTEM_PROPERTIES: readonly string[];
+/** Result of matching a form AttributePath against the CK metadata of a type. */
+type CanonicalPath = {
+    kind: 'attribute';
+    name: string;
+    attribute: CkAttributeInfo;
+} | {
+    kind: 'system';
+    name: string;
+} | {
+    kind: 'rtId';
+} | {
+    kind: 'dotted';
+    path: string;
+} | {
+    kind: 'unknown';
+    path: string;
+};
+/**
+ * Canonicalises a form AttributePath (forms use PascalCase, the CK API camelCase):
+ * system properties and attributes match case-insensitively, `rtId` is reported separately
+ * (never a field), dotted paths are reported as deferred, everything else is unknown.
+ */
+declare function canonicalisePath(path: string | null | undefined, attributes: readonly CkAttributeInfo[]): CanonicalPath;
+/** Converts `SftpConfiguration` / `System.Communication/SftpConfiguration` to `sftp-configuration`. */
+declare function toKebabTypeKey(rtCkTypeId: string): string;
+
+/**
+ * Parses a `VisibleWhen` expression (`Path=value` or `Path=*`). The expression is split at the
+ * FIRST `=`, so values may contain `=`. The path is canonicalised against the type's attributes
+ * (system properties allowed); returns `null` for an empty, malformed or unresolvable expression.
+ */
+declare function parseVisibleWhen(expression: string | null | undefined, attributes: readonly CkAttributeInfo[]): VisibleWhenRule | null;
+/**
+ * Evaluates a rule against the current form values.
+ *
+ * - `*`: visible when the source has a value, or (for a secret source) when the server reports the
+ *   secret as set (`secretPresence[path] === true`).
+ * - Booleans compare against `true`/`false` (case-insensitive).
+ * - Enums compare against the key or the name (case-insensitive) using `enumOptions`.
+ * - Everything else compares the string form (case-sensitive).
+ */
+declare function isVisible(rule: VisibleWhenRule | undefined | null, values: Record<string, unknown>, secretPresence?: Record<string, boolean>, enumOptions?: {
+    key: number;
+    name: string;
+}[]): boolean;
+
+/** Record infos keyed by versioned `ckRecordId` (as found in `CkAttributeInfo.ckRecordId`). */
+type RecordInfoMap = Record<string, CkRecordInfo>;
+/** Attribute metadata the mapper needs (a subset of {@link CkAttributeInfo}). */
+type MapperAttribute = Pick<CkAttributeInfo, 'attributeName' | 'valueType' | 'isOptional'> & Partial<Pick<CkAttributeInfo, 'enumOptions' | 'ckRecordId'>>;
+/**
+ * Converts a raw API value to the form value shape of the given attribute.
+ * Records/record arrays become arrays of flat dicts; unsupported types pass through unchanged.
+ */
+declare function toFormValue(raw: unknown, attribute: MapperAttribute, records?: RecordInfoMap): unknown;
+/**
+ * Maps form values to `RtEntityAttributeInput[]` for the given attributes (in the given order).
+ * Values whose key is absent from `values` are skipped.
+ */
+declare function toAttributeInputs(values: Record<string, unknown>, attributes: readonly MapperAttribute[], records?: RecordInfoMap): {
+    attributeName: string;
+    value: unknown;
+}[];
+/**
+ * Parses a form `Default` string (or a CK `defaultValues[0]`) into the form value shape:
+ * Int via parseInt, Double via parseFloat, Boolean via 'true'/'false', ENUM by name or key,
+ * DateTime as ISO -> Date, arrays as a JSON array or a comma list. Returns `undefined` when the
+ * input is empty or cannot be parsed.
+ */
+declare function parseDefault(raw: unknown, attribute: MapperAttribute): unknown;
+
+/** One selected reference target as held by a reference control. */
+interface EntityFormReferenceValue {
+    rtId: string;
+    ckTypeId: string;
+    displayName?: string;
+}
+interface BuildChangeSetOptions {
+    /** Record metadata keyed by versioned ckRecordId, for type conversion of record sub-values. */
+    records?: Record<string, CkRecordInfo>;
+    /**
+     * attributeNames of secrets whose clear the user staged (Q8, edit mode). Sent as
+     * `clearSecretAttributes` unless a new value was typed for the same field (mutually exclusive —
+     * the typed value wins, the server would reject both).
+     */
+    clearedSecrets?: ReadonlySet<string>;
+}
+/**
+ * The association `roleName` written in `RtEntityAssociationInput`: the navigation property name
+ * with a lower-case first letter (the backend matches it case-insensitively; verified live, and
+ * the role id `System/Related` is NOT accepted as roleName — it is silently ignored).
+ */
+declare function associationRoleName(navigationPropertyName: string): string;
+/**
+ * Builds the change set of a form (D6: only dirty controls on edit).
+ *
+ * - `current` is the form's enabled value: a key that is absent (disabled control, e.g. hidden by
+ *   VisibleWhen) is never sent.
+ * - Create mode sends every non-empty editable value (defaults included) plus `rtWellKnownName`.
+ * - Edit mode sends only attributes whose value differs from `initial`; read-only, `afterCreate`
+ *   and unsupported fields and `rtWellKnownName` are never sent.
+ * - Secrets: an empty secret is left out (= unchanged); a typed secret is always sent. A staged
+ *   clear (edit mode, `options.clearedSecrets`) goes to `clearSecretAttributes` instead.
+ * - Associations: diff of the selected targets by rtId; a single-valued replace produces DELETE old
+ *   plus CREATE new.
+ * - View mode produces an empty change set.
+ */
+declare function buildChangeSet(initial: Record<string, unknown>, current: Record<string, unknown>, model: ResolvedEntityForm, mode: EntityFormMode, _secretPresence?: Record<string, boolean>, options?: BuildChangeSetOptions): EntityFormChangeSet;
+
+/** Shape of one attribute row of `entityFormGetCkType` / `entityFormGetCkRecord`. */
+interface RawCkAttribute {
+    attributeName: string;
+    attributeValueType: string;
+    isOptional: boolean;
+    ckAttributeId?: {
+        fullName: string;
+    } | null;
+    attribute?: {
+        description?: string | null;
+        defaultValues?: (unknown | null)[] | null;
+        metaData?: ({
+            key: string;
+            value?: string | null;
+        } | null)[] | null;
+        ckEnum?: {
+            values: ({
+                key?: number | null;
+                name?: string | null;
+            } | null)[];
+        } | null;
+        ckRecord?: {
+            ckRecordId: {
+                fullName: string;
+            };
+        } | null;
+    } | null;
+}
+interface RawBaseType {
+    rtCkTypeId: string;
+    isAbstract?: boolean;
+    baseType?: RawBaseType | null;
+}
+interface RawRole {
+    rtRoleId: string;
+    navigationPropertyName: string;
+    multiplicity: string;
+    rtTargetCkTypeId: string;
+    rtOriginCkTypeId: string;
+}
+/** Shape of one type of `entityFormGetCkType`. */
+interface RawCkType {
+    rtCkTypeId: string;
+    isAbstract: boolean;
+    description?: string | null;
+    ckTypeId: {
+        fullName: string;
+    };
+    baseType?: RawBaseType | null;
+    attributes?: {
+        items?: (RawCkAttribute | null)[] | null;
+    } | null;
+    associations?: {
+        in?: {
+            all?: (RawRole | null)[] | null;
+        } | null;
+        out?: {
+            all?: (RawRole | null)[] | null;
+        } | null;
+    } | null;
+}
+/** Shape of one record of `entityFormGetCkRecord`. */
+interface RawCkRecord {
+    ckRecordId: {
+        fullName: string;
+    };
+    isAbstract?: boolean;
+    attributes?: {
+        items?: (RawCkAttribute | null)[] | null;
+    } | null;
+}
+/**
+ * The CK attribute metaData `secret` marker: `true`, `false` (explicit opt-out of the
+ * credential-name rule) or `undefined` when there is no (valid) marker.
+ */
+declare function secretMetaDataMarker(metaData: readonly ({
+    key: string;
+    value?: string | null;
+} | null)[] | null | undefined): boolean | undefined;
+/** True when the CK attribute metaData marks the attribute as secret (`secret = true`). */
+declare function isSecretMetaData(metaData: readonly ({
+    key: string;
+    value?: string | null;
+} | null)[] | null | undefined): boolean;
+/** Maps a raw `entityFormGetCkType` item to {@link CkTypeInfo}. */
+declare function toCkTypeInfo(raw: RawCkType): CkTypeInfo;
+/** Maps a raw `entityFormGetCkRecord` item to {@link CkRecordInfo}. */
+declare function toCkRecordInfo(raw: RawCkRecord): CkRecordInfo;
+
+export { BUILT_IN_DEFAULT_FORM, DEFAULT_ENTITY_FORMS_MESSAGES, DEFAULT_GENERATED_SECTION_TITLE, DEFAULT_SECTION_KEY, ENTITY_FORM_ACTION_CONFIRMATION, ENTITY_FORM_BEFORE_SAVE, ENTITY_FORM_DANGER_CONFIRMATION, ENTITY_FORM_FALLBACK_FORMS, ENTITY_FORM_LABEL_RESOLVER, ENTITY_FORM_SECRET_KEY_RING_CONFIGURED, ENTITY_FORM_SECRET_PLACEHOLDER_VALUES, ENTITY_FORM_UNSET_PLACEHOLDER_VALUES, ENTITY_LIST_ROW_CLASS, ENTITY_PAGE_NEW, ENTITY_PAGE_TYPE_QUERY_PARAM, EntityFormComponent, EntityFormDataService, EntityFormRecordsFieldComponent, EntityFormReferenceFieldComponent, EntityFormSaveVeto, EntityFormSecretEditorComponent, EntityFormService, EntityListComponent, EntityListDataSourceDirective, EntityPageActionsDirective, EntityPageComponent, GENERATED_SECTION_KEY, SYSTEM_PROPERTIES, associationFieldKey, associationRoleName, autoEditorFor, buildChangeSet, canonicaliseEntityFormPrefill, canonicalisePath, ckTypeDisplayName, ckTypeShortName, confirmEntityFormAction, confirmEntityFormDanger, entityDeleteConfirmation, entityFormCatalog, entityFormKey, entityFormPrefillState, entityFormRoutes, entityFormTypeTitles, entityFormUnsetPlaceholderFields, entityFormUnsetPlaceholderLookup, entityListAttributeNames, entityListIncludesDerivedTypes, formatEntityFormsMessage, humanizeCkTypeName, isChainEndForm, isEditorCompatible, isEntityFormSaveVeto, isEntityFormUnsetPlaceholder, isSecretMetaData, isVisible, localizeEntityForm, localizeEntityFormTitle, localizeEntityListColumns, mergeEntityFormPrefill, mergeEntityFormsMessages, parseDefault, parseEntityForm, parseEntityForms, parseVisibleWhen, pickEntityForm, provideEntityFormFallbacks, resolveEntityForm, resolveEntityFormLabel, resolveListDefaultSort, runEntityFormBeforeSave, secretMetaDataMarker, secretStatusLabelsOf, selectFallbackForms, shortTypeName, toAttributeInputs, toCkRecordInfo, toCkTypeInfo, toEntityListColumn, toEntityListRow, toFormValue, toKebabTypeKey, toListViewRowClass, withFallbackForms };
+export type { BuildChangeSetOptions, CanonicalPath, CkAssociationRoleInfo, CkAttributeInfo, CkRecordInfo, CkTypeInfo, EntityFormActionConfirmation, EntityFormActionRequest, EntityFormBeforeSaveContext, EntityFormBeforeSaveHook, EntityFormBeforeSaveOutcome, EntityFormBeforeSaveResult, EntityFormCatalogEntry, EntityFormChangeSet, EntityFormColumnDef, EntityFormDangerConfirmation, EntityFormDefinition, EntityFormEditor, EntityFormFieldDef, EntityFormLabelKind, EntityFormLabelRequest, EntityFormLabelResolver, EntityFormLoadKey, EntityFormLoadResult, EntityFormMode, EntityFormPrefillOptions, EntityFormPrefillValues, EntityFormRecordColumn, EntityFormReferenceValue, EntityFormRoutesOptions, EntityFormSecretFieldState, EntityFormSectionDef, EntityFormSortDef, EntityFormSource, EntityFormTargetRef, EntityFormUnsetPlaceholderLookup, EntityFormUnsetPlaceholderTarget, EntityFormUnsetPlaceholderValues, EntityFormValueState, EntityFormsMessages, EntityListBooleanDisplay, EntityListCellLabels, EntityListColumnOptions, EntityListCreateRequest, EntityListOpenRequest, EntityListRow, EntityListRowClass, EntityListSortDescriptor, EntityPageActionBarPosition, EntityPageActionsContext, EntityPageDeletedEvent, EntityPageEditMode, EntityPageInitialValues, EntityPageNavigateEvent, EntityPageSavedEvent, EntityPageView, RawRtEntityRow, ReadOnlyMode, ResolveEntityFormOptions, ResolvedEntityForm, ResolvedField, ResolvedListColumn, ResolvedSection, VisibleWhenRule };