import * as _angular_core from '@angular/core'; import { InjectionToken, Type, Signal, OnInit, ElementRef, NgZone } from '@angular/core'; import * as _masterteam_components_entities from '@masterteam/components/entities'; import { MTDateFormatType } from '@masterteam/components'; import { MTIcon } from '@masterteam/icons'; import { HttpContext } from '@angular/common/http'; import { Popover } from 'primeng/popover'; import { Observable } from 'rxjs'; import { CdkDragDrop } from '@angular/cdk/drag-drop'; import { TranslocoService } from '@jsverse/transloco'; interface ComparisonValueSide { raw: unknown; value: unknown; display?: string | null; } interface ValueComparison { kind: 'Value'; oldValue: ComparisonValueSide; newValue: ComparisonValueSide; } interface EntityComparisonField { propertyKey: string; label: string; value: unknown; display?: string | null; } type EntityComparisonOperation = 'CreateRecord' | 'UpdateRecord' | 'DeleteRecord'; interface EntityListComparisonRow { kind: 'ModuleRecord'; operation: EntityComparisonOperation; entityId: number; oldValues: EntityComparisonField[]; newValues: EntityComparisonField[]; } interface EntityListComparison { kind: 'EntityList'; targetModuleKey: string; rows: EntityListComparisonRow[]; } type PropertyValueComparison = ValueComparison | EntityListComparison; /** * The runtime ids an entity renderer needs to fetch anything of its own. * * A rendered `EntityData` describes one *value*; it carries no idea of which * level or level-data row it was read from. Most view types never need one — * the value is the whole answer. `EntityList` is the exception: a module-backed * list's rows live in another module and are scoped by the owning level-data * row, so the renderer cannot resolve them from the value alone. * * Hosts that know these ids publish them through `EntityRuntimeContextStore`; * hosts that do not simply leave it unprovided and every renderer keeps its * value-only behaviour. */ interface EntityRuntimeContext { /** Owning level id — addresses the per-level configuration override. */ levelId?: number | string | null; /** Owning level-data row — what related records are scoped to. */ levelDataId?: number | string | null; /** * The record that owns the list, for the reads addressed to it rather than * to its level — the saved list's `entity-lists/comparison`. Set by a host * that knows the row it renders (a table cell); a record preview leaves it. */ ownerKind?: 'ModuleData' | 'LevelData' | null; ownerId?: number | null; } /** * Publishes an `EntityRuntimeContext` to a subtree of entity renderers. * * Deliberately **not** `providedIn: 'root'`: an unprovided store is the signal * that the host has no runtime context, and every consumer injects it * `{ optional: true }`. Providing it on a component scopes it to that * component's view — which is also how a nested renderer shuts the context * off for its own children (see `EntityListField`, whose table cells must not * re-enter the fetching path). */ declare class EntityRuntimeContextStore { readonly context: _angular_core.WritableSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * The component `mt-entity-list-preview` renders inline instead of its * count-and-drawer trigger, when a runtime context is available. * * Indirection rather than a direct import because the real renderer is * `mt-entity-list-field` (`@masterteam/components/business-fields`), which * builds on `mt-table` — and `table` already imports `entities`, so importing * it back here would make the two entry points circular. The provider lives * with the component: `provideEntityListTablePreview()`. * * The component is created with `NgComponentOutlet` and receives * `propertyId`, `runtimeContext`, `configuration`, `initialValue`, `readonly` * and `label` as inputs. */ declare const ENTITY_LIST_TABLE_COMPONENT: InjectionToken>; /** * The record a calculated value was read from. Set on `EntityData` by a host * that knows it (a record preview), so the value's calculated-value mark can * explain how the saved value was calculated. */ interface EntityCalculationSource { /** The fetch context the record was read from: `level:12`, `level:12/module:5`. */ contextKey: string; /** The level-data or module-data id. */ recordId: number; } /** What `mt-entity-calculated-indicator` needs to open an explanation. */ interface EntityCalculationExplanationTarget { source: EntityCalculationSource; /** The canonical property key. */ propertyKey: string; /** The field label, shown as the explanation's title. */ label: string; /** The raw value on screen, compared with the saved one. */ displayedValue: string | undefined; /** How the value is shown, when the response does not say. */ viewType?: string; /** * Names of status keys the host already knows (the value on screen), so a * status rule reads as its name rather than its key. */ statusNames?: Record; } /** * `GET properties/calculation-explanation`. The backend returns these as * camelCase strings; anything else is treated as unavailable. `summarized` is * an explanation too: a large schedule rollup, with totals over every item and * only some of the items listed. */ type CalculationExplanationStatus = 'available' | 'summarized' | 'notCaptured' | 'unsupported' | 'limitExceeded' | 'restricted' | 'valueChanged' | 'notCalculated'; /** * What the explanation describes. `savedCalculation` is the calculation that * produced the persisted value; `currentCalculation` evaluates current data * read-only (native schedule fields) and claims no saved revision. */ type CalculationExplanationBasis = 'savedCalculation' | 'currentCalculation'; /** A JSON value captured by the backend, shown as plain text. */ type CalculationExplanationValue = string | number | boolean | null | CalculationExplanationValue[] | { [key: string]: CalculationExplanationValue; }; /** * Current, authorized display metadata of a property. Names are today's, not * the ones at calculation time; the numbers always come from the calculation. */ interface CalculationPropertyDisplay { key: string; name: string; nameEn: string | null; nameAr: string | null; viewType: string; } /** * The calculation of one value. Not wrapped in the usual response envelope: * the endpoint returns this object as is. */ interface CalculationExplanationResponse { status: CalculationExplanationStatus | (string & {}); propertyKey: string; /** Absent from responses before the backend added current calculations. */ basis?: CalculationExplanationBasis | (string & {}); valueVersion: string | null; /** The formula was changed after this value was saved. */ definitionChanged: boolean; /** Only with `available` and `summarized`. */ explanation?: CalculationExplanationDocument | null; /** The persisted, normalized value the explanation belongs to (saved basis). */ savedValue?: string | null; /** The explained property, as it is configured now. */ display?: CalculationPropertyDisplay | null; } type CalculationExplanationProvider = 'formula' | 'status' | 'nativeMethod' | 'codeBuilder' | 'schedule'; interface CalculationExplanationDocument { schemaVersion: number; calculationId: string; provider: CalculationExplanationProvider | (string & {}); providerVersion: string; engineVersion: string; status: string; /** * `summary`: a large schedule rollup whose items are given as totals, with * only the highest-weight ones listed (response status `summarized`). Absent * on a complete explanation. */ completeness?: 'summary' | (string & {}) | null; /** * The saved formula with internal property references; for a native method * or a schedule field, an English description of the calculation instead. * Diagnostic only: never shown, the UI builds its wording from the nodes. */ formula: string; /** * A stable key for a server-authored description (`calculation.method.*`, * `calculation.schedule.*`, `calculation.status.*`). Absent on older saved * captures and on ordinary formulas. */ descriptionKey?: string | null; definitionHash: string; calculatedAt: string; /** The formula with every input replaced by its value: `(20 * 2)`. */ formulaWithValues: string | null; /** The typed engine output, before the backend normalized it for saving. */ result: CalculationExplanationValue; rootNodeId: number; nodes: CalculationExplanationNode[]; sources: CalculationExplanationSourceRecords[]; /** Progress rollups behind `@Schedule::*_progress` references. */ schedule?: ScheduleCalculationExplanation[]; /** Status rules in configured order (status provider). */ statusRules?: CalculationStatusRuleExplanation[]; } type CalculationExplanationNodeKind = 'literal' | 'input' | 'binary' | 'unary' | 'function' | 'conditional' | 'array' | 'table' | 'semantic' | 'selection' | 'method' | 'codeBlock'; interface CalculationExplanationNode { id: number; kind: CalculationExplanationNodeKind | (string & {}); operation: string | null; /** Diagnostic text (formula source or an English fact label); never shown. */ expression: string; /** A stable key for a native fact's label (`calculation.fact.*`). */ labelKey?: string | null; children: number[]; argumentNames: (string | null)[]; /** `notEvaluated` (a branch never reached) is not an evaluated `null`. */ state: 'evaluated' | 'notEvaluated' | (string & {}); value?: CalculationExplanationValue; reference: string | null; /** The referenced property, for an input whose source was authorized. */ display?: CalculationPropertyDisplay | null; /** * The rows behind a vector input: `recordIds[i]` is the row of `value[i]`, * nulls and repeats included. Never re-sorted, never taken from `sources`. */ recordIds?: number[]; /** * A summarized rollup (a large schedule's progress, or its baseline count): * how many rows it read. It then has no children and lists no rows. */ rowCount?: number | null; } /** A record a calculation read, to be named through an authorized read. */ interface CalculationRecordRef { /** `Level:1/Module:4`, as the explanation wrote it. */ contextKey: string; recordId: number; } interface CalculationExplanationSourceRecords { tablePath: string; contextKey: string | null; recordIds: number[]; propertyKeys: string[]; } interface CalculationStatusRuleExplanation { key: string; order: number; state: 'evaluated' | 'failed' | 'notEvaluated' | (string & {}); selected: boolean; /** The rule's condition, explained like a formula. */ condition: CalculationExplanationDocument | null; } interface ScheduleCalculationExplanation { /** The semantic node it belongs to: `Schedule::actual_progress`. */ reference: string; asOfUtc: string; weightMode: 'workingDays' | 'explicitWeight' | (string & {}); aggregation: 'weightedAverage' | 'arithmeticMean' | 'empty' | (string & {}); formulaWithValues: string; result: number; roundingDigits: number; roundingMode: string; includeMilestones: boolean; excludeSameDayMilestones: boolean; leafOnly: boolean; excludedRowCount: number; notes: string[]; /** Every contributor, or with a `summary` only the highest-weight ones. */ contributors: ScheduleCalculationContributor[]; /** * Totals over every contributor, when there are more than an explanation * lists. Absent when `contributors` is the complete list. */ summary?: ScheduleCalculationSummary | null; } /** * A large rollup in totals, taken from the same pass that calculated it: * `weightedProgressTotal ÷ weightTotal`, bounded to 0–100 and rounded, is the * result. With a simple average the weight total is the number of items and * the weighted total the sum of their progress. */ interface ScheduleCalculationSummary { totalContributors: number; /** How many of them `contributors` lists. */ shownContributors: number; includedContributors: number; zeroWeightExcludedContributors: number; missingInputContributors: number; weightTotal: number; weightedProgressTotal: number; byModule: ScheduleCalculationSummaryGroup[]; } /** The items of one kind (`Task`, `Milestone`, …) in a summarized rollup. */ interface ScheduleCalculationSummaryGroup { moduleKey: string; contributors: number; includedContributors: number; weightTotal: number; weightedProgressTotal: number; /** Percentage points these items add to the result; the groups add up to it. */ resultContribution: number; } interface ScheduleCalculationContributor { recordId: number; moduleKey: string; contextKey: string | null; progress: number; weight: number; inputMissing: boolean; includedInAggregation: boolean; plannedStart: string | null; plannedFinish: string | null; plannedCalculation: PlannedProgressExplanation | null; } /** How one item's planned progress was derived from its dates and calendar. */ interface PlannedProgressExplanation { result: number; rule: 'missingDates' | 'invalidDateRange' | 'beforeStart' | 'afterFinish' | 'milestoneDueDate' | 'noWorkingTime' | 'elapsedWorkingMinutes' | (string & {}); elapsedWorkingMinutes: number | null; totalWorkingMinutes: number | null; asOfLocal: string; timeZoneId: string; calendarSource: string; workDayStartMinute: number; workDayEndMinute: number; /** Sunday = 0. */ workingDays: number[]; holidays: string[]; plannedStart: string | null; plannedFinish: string | null; } /** A recalculation covering this value is running, or queued behind another. */ type EntityCalculationStatus = 'running' | 'waiting' | 'delayed'; /** How a calculated value moved between two reads of the same record. */ interface EntityCalculationChange { /** Signed difference; `null` for a value that has no numeric difference. */ delta: number | null; /** The value's unit as the backend formats it, e.g. `SAR` or `%`. */ unit: string; /** Whether the unit is written before the amount. */ unitLeads: boolean; fractionDigits: number; /** The value as it read before and after, in full. */ previous: string; current: string; /** While true a chip beside the value shows the change. Numbers only. */ recent: boolean; } type EntityViewType = 'Text' | 'LongText' | 'Date' | 'DateTime' /** * Time-of-day. The value on the wire is still a full ISO instant (the * backend stores and returns the same shape as `DateTime`); only the * rendering and the picker are narrowed to the clock time. */ | 'Time' | 'Number' | 'Percentage' | 'Status' | 'Currency' | 'Checkbox' | 'User' | 'MultiUser' | 'Lookup' | 'LookupMultiSelect' /** * Calculated, read-only lookup resolved by the backend to the schema phase * gate the record currently sits on. Never editable at runtime. */ | 'PhaseGate' /** * Calculated, read-only KPI performance — a semicircle gauge (ported from * SPlus v3's `app-performance-gauge`). The value is an * {@link EntityPerformanceScoreValue}; never editable at runtime. */ | 'PerformanceScore' | 'Attachment' | 'Location' | 'LookupMatrix' | 'LookupModuleCheckList' | 'LeafDetails' | 'Connection' | 'ScheduleItemSelector' /** * A nested list of related rows. Read-only here: the editable runtime is * `mt-entity-list-field`, which fetches its own rows; this view type is what * arrives when an `EntityList` property is itself a *column* of that fetch — * a calculated inline list the backend renders inline, such as the phase * gate `phasegate_checklists` virtual property. The value carries its own * rows, so nothing is fetched to display it. */ | 'EntityList' /** * A stored icon reference. The value is a plain icon key (e.g. * `custom.strategy`) — the backend's own system icon property (Name/Icon on * a Template) reports this view type. Rendered as the actual glyph via * `mt-icon`, not as the raw key string; `mt-icon` degrades to an empty glyph * for an unknown key. */ | 'Icon' /** * A stored color — a plain `#rrggbb` string, as `mt-color-picker-field` * writes it. Rendered as a swatch next to the hex code, not as bare text. */ | 'Color' /** * Layout marker, not a value. Rendered full-width and non-resizable; the * preview layer (`groupEntitiesIntoSections`) turns each marker into a titled * section box that owns every entity following it until the next marker. */ | 'Section'; type EntityLabelPosition = 'top' | 'bottom'; /** Entity size – controls column span (1-24) inside a 24-column grid */ type EntitySize = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24; /** * Entity row span – how many rows of the 24-column grid the entity occupies. * Lets a tall entity (e.g. a PerformanceScore gauge) sit beside a column of * stacked entities instead of leaving empty space next to it. */ type EntityRowSpan = 1 | 2 | 3 | 4; declare const ENTITY_ROW_SPANS: readonly EntityRowSpan[]; interface EntityBaseConfig { /** Column span of the entity card (1-24). Default: 8 */ size?: EntitySize; /** Row span of the entity card (1-4). Default: 1 */ rowSpan?: EntityRowSpan; /** Whether to show a dashed border around the entity card */ showBorder?: boolean; /** Whether to hide the entity name label. Prefer hideLabel for new config. */ hideName?: boolean; /** Whether to hide the entity label */ hideLabel?: boolean; /** Controls whether the label is rendered above or below the value */ labelPosition?: EntityLabelPosition; /** Legacy misspelled alias kept for compatibility */ labelPostion?: EntityLabelPosition; /** Whether the entity content is aligned to the end (right in LTR) */ alignEnd?: boolean; /** * Custom localized label override. When present it replaces the catalog * label; it also serves as the heading for `Section` markers. */ label?: EntitySectionLabel; /** * Admin-authored explanatory note, localized. When present the entity grows a * small info affordance at its top-end corner that reveals this text on hover. * * Plain text, deliberately. Every string inside a `configuration` payload is * sanitized server-side with the PlainText profile, which strips HTML tags * outright — rich markup authored here would come back as bare words. The * renderer preserves the author's own line breaks instead. */ info?: EntitySectionLabel; /** * Renders the entity as the card's header instead of a grid cell: a * full-width band pinned above every other entity, showing the value * centred with no label. Its presence is the switch — absent ⇒ an ordinary * cell. * * Text view types only, and one per display area. The customization drawer * enforces both; the renderers only honour the first Text entity carrying * it, so a configuration written elsewhere cannot produce two headers. */ header?: EntityHeaderConfig; } /** Colours of an entity rendered as a card header (`EntityBaseConfig.header`). */ interface EntityHeaderConfig { /** Band background, `#rrggbb`. Absent ⇒ a light tint of the primary colour. */ backgroundColor?: string | null; /** Top border, `#rrggbb`. Absent ⇒ the primary colour. */ borderColor?: string | null; } interface EntityUserConfig extends EntityBaseConfig { showDisplayName?: boolean; showPhoneNumber?: boolean; showEmail?: boolean; /** * Whether the avatar is rendered at all. When `false` neither the user's * picture nor the generic fallback icon shows — only the name remains. */ showAvatar?: boolean; /** Maximum users shown before the MultiUser preview collapses behind +N. */ maxVisibleUsers?: number; } /** * One Progress/Percentage color rule. Bounds are inclusive and at least one of * `minValue`/`maxValue` must be present — a rule with neither matches nothing. */ interface PercentageColorRule { minValue?: number | null; maxValue?: number | null; color: string; } /** * Where a Percentage property's colour comes from. * * - `rules` — the value itself picks the colour out of `colorRules`. * - `property` — another property on the same record supplies it, so the bar * follows that property's own colour (a Status's colour, a Lookup item's * colour) rather than the percentage it is showing. * * An absent mode reads as `rules`: every configuration authored before this * existed is value-based. */ type PercentageColorMode = 'rules' | 'property'; /** * The property that supplies the colour in `property` mode. * * Both identifiers are stored on purpose. `propertyId` is what the backend * resolves against, and `propertyKey` is what a renderer holding an already * rendered record can match without a catalog lookup — rendered properties * carry their key, not the catalog id they came from. */ interface PercentageColorPropertyRef { /** Catalog id of the colour-bearing property. */ propertyId: number; /** Its key, for matching against a rendered record. */ propertyKey?: string | null; /** * Its view type — `Status`, `Lookup`, `LookupMultiSelect` or `PhaseGate`. * Deliberately a plain string: it arrives from stored JSON, and a view type * this build does not know about must survive the round trip rather than be * normalised away. */ viewType?: string | null; } interface EntityPercentageConfig extends EntityBaseConfig { /** * The colour to paint the bar with. The backend resolves the configuration — * the rules, or the source property in `property` mode — and ships the winner * here on render/value/fetch responses, so this always wins over a * client-side evaluation. */ color?: string; /** Which of the two colour strategies applies. Absent ⇒ `rules`. */ colorSource?: PercentageColorMode | null; /** The colour-bearing property. `property` mode only. */ colorProperty?: PercentageColorPropertyRef | null; /** Ordered rules — evaluated in order, first match wins. `rules` mode only. */ colorRules?: PercentageColorRule[] | null; /** * Fallback colour. In `rules` mode it applies when no rule matches; in * `property` mode when the source property is empty or its value carries no * colour of its own. */ defaultColor?: string | null; } /** * How wide a `PerformanceScore` gauge may grow inside its cell. The gauge is * centred and shrinks with a narrower cell; this only caps it. Absent ⇒ * `medium`. */ type EntityPerformanceScoreChartSize = 'small' | 'medium' | 'large' | 'full'; interface EntityPerformanceScoreConfig extends EntityBaseConfig { /** Set from the customization drawer. */ chartSize?: EntityPerformanceScoreChartSize; } interface LeafLevelSavedConfig { /** Position order for this level entity in the preview grid */ order: number; /** Column span (1-24), persisted from drag-resize */ size?: EntitySize; /** Status keys the user has chosen to display */ selectedStatuses: string[]; /** * Custom label for THIS tile, localized. * * Per-level rather than on the parent property because one LeafDetails * property renders one tile per child level per projection — a single shared * label would paint the same text on every one of them and leave the tiles * indistinguishable. Same reasoning as `order` and `size`, which are already * per-level. Empty → the child level's own name. */ label?: EntitySectionLabel; } /** * Per-level display overrides for the *phase* projection of a LeafDetails * property — the sibling of {@link LeafLevelSavedConfig}. The two are kept * apart on purpose: one level can contribute a status item, a phase item, or * both, each with its own slot and width in the grid. * * Unlike `leafLevels`, an absent `leafPhases` map hides every phase item. * Phases are strictly opt-in so existing cards do not grow badges they were * never configured with. */ interface LeafPhaseSavedConfig { /** Position order for this level's phase entity in the preview grid */ order: number; /** Column span (1-24), persisted from drag-resize */ size?: EntitySize; /** Phase keys the user has chosen to display */ selectedPhases: string[]; /** Custom label for this phase tile, localized. See `LeafLevelSavedConfig.label`. */ label?: EntitySectionLabel; } interface EntityLeafDetailsConfig extends EntityBaseConfig { /** Per-level display overrides for LeafDetails entities */ leafLevels?: Record; /** Per-level phase-badge overrides for LeafDetails entities */ leafPhases?: Record; } /** * Per-source-level display overrides for a Connection entity. Unlike * `LeafLevelSavedConfig` an absent entry does not hide the level — every source * level always renders as its own item and simply inherits the parent's * order/size until the user drags it. */ interface ConnectionLevelSavedConfig { /** Position order for this source-level item in the preview grid */ order?: number; /** Column span (1-24), persisted from drag-resize */ size?: EntitySize; } interface EntityConnectionConfig extends EntityBaseConfig { /** Per-source-level display overrides for Connection entities */ connectionLevels?: Record; } /** * One source level a Connection property can link to, as published on the * property catalog's `configuration.sourceLevels`. Its `name` supplies the * label of the split item that represents this level. */ interface ConnectionSourceLevelConfig { levelId: number; levelKey?: string; name?: EntitySectionLabel | string; connectionId?: number; [key: string]: unknown; } /** Catalog `configuration` shape of a `Connection` property. */ interface ConnectionCatalogConfiguration { sourceLevels?: ConnectionSourceLevelConfig[]; [key: string]: unknown; } /** One connected record inside a Connection value's `Sources` array. */ interface EntityConnectionSourceValue { sourceLevelId?: number; SourceLevelId?: number; sourceLevelDataId?: number; SourceLevelDataId?: number; display?: string; Display?: string; name?: string; Name?: string; [key: string]: unknown; } /** A localized label ({ en, ar }) — used by section headings and custom labels. */ interface EntitySectionLabel { en?: string; ar?: string; } /** Configuration for a `Section` layout marker (`viewType: 'Section'`). */ interface EntitySectionConfig extends EntityBaseConfig { /** Section heading, localized. Empty/absent renders a header-less box. */ label?: EntitySectionLabel; } type EntityConfiguration = EntityBaseConfig | EntityUserConfig | EntityPercentageConfig | EntityPerformanceScoreConfig | EntityLeafDetailsConfig | EntityConnectionConfig | EntitySectionConfig; /** Value shape for a translatable Text/LongText property: `{ display, ar?, en? }`. */ interface EntityTranslatableTextValue extends EntitySectionLabel { display: string; } interface EntityStatusValue { key: string; display: string; color: string; description?: string; } interface EntityLookupValue { key: string; display: string; color: string; description?: string; } type EntityMultiLookupValue = EntityLookupValue[]; /** * A `PhaseGate` value — the schema phase gate the record currently sits on. * * Calculated and read-only: the backend owns it, nothing in the runtime writes * it back. `key` is the stable phase-gate key; the schema phase-gate *id* rides * on the owning entity's `rawValue`, not here. `display` is resolved for the * request language, and `en`/`ar` carry the explicit per-language labels so the * renderer can follow a client-side language switch without a refetch. */ interface EntityPhaseGateValue { key: string; display: string; en?: string; ar?: string; description?: string; /** * Optional presentation metadata (hex). Absent → the renderer's * `DEFAULT_PHASE_GATE_COLOR` neutral badge. */ color?: string; } /** * One performance band of a `PerformanceScore` gauge — a status item with the * range of performance it covers. Bounds are percentages; a missing `from` * starts at the gauge minimum and a missing `to` runs to the gauge maximum. */ interface EntityPerformanceScoreStatus { key: string; display: string; color: string; from?: number | null; to?: number | null; } /** * A `PerformanceScore` value, calculated by the backend. * * - `performance` — the score, in percent. May exceed 100 or fall below 0; the * gauge widens its scale to the outermost band, then clamps the marker. * - `status` — the band the score currently sits in. Absent → resolved here * from `statuses` by range. * - `statuses` — every band, drawn as coloured arc segments. Absent/empty → a * single arc painted in the status colour. */ interface EntityPerformanceScoreValue { performance: number | string | null; status?: EntityPerformanceScoreStatus | null; statuses?: EntityPerformanceScoreStatus[] | null; } interface EntityUserValue { id?: string; userName?: string; name?: string; displayName?: string; photoUrl?: string; phoneNumber?: string; email?: string; /** * `false` when the user is no longer linked to the current application * (e.g. removed/deleted) but is still referenced by historical records. */ isLinkedToCurrentApplication?: boolean; } type EntityMultiUserValue = EntityUserValue[]; interface LeafDetailsStatusSummary { key: string; display: string; color: string | null; /** Always 0 in preview/configuration context; populated from runtime fetch */ count: number; } interface LeafDetailsCatalogStatusValue { key: string; display: string; description?: string | null; color: string | null; icon?: string | null; order?: number; } /** * One phase bucket of a child level, as published on the catalog * `configuration` and counted at runtime. `id` is the schema phase-gate id and * is `null` on the backend's synthetic "No current phase" bucket — `key` is * what the saved configuration selects on, so it is the stable identifier here. */ interface LeafDetailsCatalogPhaseValue { id?: number | null; key: string; display: string; color: string | null; icon?: string | null; order?: number; } interface LeafDetailsPhaseSummary { id?: number | null; key: string; display: string; color: string | null; /** Always 0 in preview/configuration context; populated from runtime fetch */ count: number; } interface LeafDetailsCatalogLevelValue { levelId: number; levelName: string; levelIcon: string; statuses: LeafDetailsCatalogStatusValue[]; /** Absent for child levels the tenant has defined no phase gates on. */ phases?: LeafDetailsCatalogPhaseValue[] | null; } /** Which projection of a child level an expanded LeafDetails item renders. */ type LeafDetailsBadgeKind = 'status' | 'phase'; interface LeafDetailsEntityValue { levelId: number; levelName: string; levelIcon: string; statuses: LeafDetailsStatusSummary[]; phases?: LeafDetailsPhaseSummary[]; /** * Set by `expandLeafDetailsEntity` on the split items. `'status'` (or absent, * for values produced before phases existed) renders the status badges; * `'phase'` renders the phase badges. */ kind?: LeafDetailsBadgeKind; } type LeafDetailsEntityCollectionValue = LeafDetailsEntityValue[]; type LeafDetailsCatalogConfiguration = LeafDetailsCatalogLevelValue[]; type EntityPropertyConfiguration = Record | LeafDetailsCatalogConfiguration | null; interface LeafDetailsRuntimeStatusDetails { key: string; display: string; color: string | null; description?: string | null; icon?: string | null; order?: number; } interface LeafDetailsRuntimeStatusCount { details: LeafDetailsRuntimeStatusDetails; count: number; } interface LeafDetailsRuntimePhaseDetails { id?: number | null; key: string; display: string; color: string | null; icon?: string | null; order?: number; } interface LeafDetailsRuntimePhaseCount { details: LeafDetailsRuntimePhaseDetails; count: number; } interface LeafDetailsRuntimeChildSchema { levelId: number; levelName: string; levelIcon: string; totalCount?: number; statuses: LeafDetailsRuntimeStatusCount[]; /** Absent for child levels the tenant has defined no phase gates on. */ phases?: LeafDetailsRuntimePhaseCount[] | null; } interface LeafDetailsRuntimeValue { totalCount?: number; childSchemas: LeafDetailsRuntimeChildSchema[]; } interface EntityAttachmentItemValue { id?: string; name?: string; fileName?: string; contentType?: string; extension?: string; size?: number; } type EntityAttachmentValue = Array; interface EntityLocationValue { display_name?: string; address?: string; lat?: string | number; lon?: string | number; lng?: string | number; [key: string]: unknown; } interface EntityConnectionValue { /** Human-readable label of the connected record (read from `rawValue.display`). */ display?: string; /** Per-source breakdown; the backend serializes it as `Sources`. */ sources?: EntityConnectionSourceValue[]; Sources?: EntityConnectionSourceValue[]; [key: string]: unknown; } /** A single property key/value captured for a checklist entry. */ interface EntityLookupCheckListPropValue { key: string; /** * Rendered value resolved by the backend, in the same shape a top-level * property of the same `viewType` carries. Paired with the matching * `EntityNestedPropertyMeta` to render it as a real typed entity. */ value: unknown; } /** One checklist entry: a selected lookup item plus its captured property values. */ interface EntityLookupCheckListItem { lookupKey: string; props: EntityLookupCheckListPropValue[]; } /** * Rendered view model for a `LookupModuleCheckList` value. * The backend renderer wraps the checklist entries in `{ items: [...] }`. */ interface EntityLookupCheckListValue { items: EntityLookupCheckListItem[]; } interface EntityScheduleItemValue { id: number; name: string; levelDataId?: number; parentId?: number | null; status?: string | null; plannedStart?: string | null; plannedFinish?: string | null; moduleKey?: string; itemType?: string; } /** One cell of an `EntityList` row. Values are always sent as strings. */ interface EntityListValueItem { propertyKey: string; rawValue?: string | null; } /** One row of an `EntityList` value. */ interface EntityListRowValue { rowId?: string; entityId?: number; values?: EntityListValueItem[]; } /** * The stored `EntityList` payload, as the backend renders it. `rows` is the * only part this view type displays — `entityIds` and the operation-marker * arrays exist for the writable runtime, not for reading. */ interface EntityListEntityValue { entityIds?: number[]; rows?: EntityListRowValue[]; } /** A `{ en, ar }` pair, as the backend's `Translatable` serializes. */ interface EntityListTranslatable { en?: string | null; ar?: string | null; } /** * The source property definition a Local list captured when its schema was * published (`PropertyDefinitionReadDto`). Server-owned and response-only: the * backend never trusts one sent back, and pins it so saved values stay * readable after the source field or module changes or is deleted. */ interface EntityListLocalFieldDefinition { key: string; name?: string | null; nameEn?: string | null; nameAr?: string | null; viewType: string; isRequired?: boolean; isTranslatable?: boolean; configuration?: Record | string | null; } /** A field's share of a row, as the form builder sizes it: ¼, ½ or full. */ type EntityListLocalFieldWidth = '25' | '50' | '100'; /** * One field of a Local list's schema. `id` is the stable local identity cells * are keyed by — a UUID, not the source property id. `label` is an optional * local override of the source label, and `required` is local to the list. */ interface EntityListLocalSchemaField { id?: string; sourceKey: string; label?: EntityListTranslatable | null; required?: boolean; hidden?: boolean; order?: number; /** * The field's size in the row dialog. Sent by the configuration screen but * **not yet stored by the backend** (`LocalEntityListField` has no such * member), so it is absent from what comes back and the dialog falls back * to its default until the backend adds it. */ width?: EntityListLocalFieldWidth | null; definition?: EntityListLocalFieldDefinition | null; } /** * A published Local schema. `version` is a UUID that changes whenever the * field set does; every mutation names the version it was built against. */ interface EntityListLocalSchema { lineageId?: string; version?: string; fields: EntityListLocalSchemaField[]; } /** One cell of a Local row. `value` is the rendered counterpart, read-only. */ interface EntityListLocalCell { fieldId: string; rawValue: string | null; value?: unknown; } /** One Local row. `rowId` is a client-generated UUID, not a record id. */ interface EntityListLocalRow { rowId: string; order: number; version: number; cells: EntityListLocalCell[]; } /** * A Local `EntityList` value (`storageMode: "Local"`): rows owned by the parent * record, stored inside it rather than as records of the source module. * * Arrives from `process-form-load` as the *projected* document — current * versions, rendered cells, and `schema` with hidden fields already removed — * and leaves as a *mutation* carrying only what changed, a fresh `mutationId`, * and no `schema`. See `.github/instructions/properties/EntityList.md`. */ interface EntityListLocalDocument { storageMode: 'Local'; formatVersion: number; schemaVersion: string; version: number; mutationId?: string; localRows: EntityListLocalRow[]; deletedRowIds?: string[]; /** Response-only: the schema the rows were projected against. */ schema?: EntityListLocalSchema | null; } /** Whether a stored or rendered `EntityList` value is a Local document. */ declare function isEntityListLocalDocument(value: unknown): value is EntityListLocalDocument; /** One source value of a selected record: stored scalar plus rendered value. */ interface EntityListSelectionRecordValue { propertyKey: string; rawValue?: string | null; value?: unknown; } /** A selected source record, with the configured read fields' values. */ interface EntityListSelectionRecord { entityId: number; values: EntityListSelectionRecordValue[]; } /** * A Selected `EntityList` value (`recordMode: "Selected"`): the source records * the user picked, by id. Selecting never creates, edits or deletes a source * record. * * Arrives from `process-form-load` as the projected document — `records` * rendered for display, `unavailableIds` for chosen records the user can no * longer see — and leaves as a *mutation* carrying only `recordMode`, * `version`, `mutationId` and the full replacement `entityIds`. See * `.github/instructions/properties/EntityList.md`. */ interface EntityListSelectionDocument { recordMode: 'Selected'; version: number; mutationId?: string; entityIds: number[]; /** Response-only: the selected records, rendered for display. */ records?: EntityListSelectionRecord[]; /** Response-only: server-captured values; never replayed as a write. */ snapshot?: unknown; /** Response-only: chosen ids whose record is deleted or no longer visible. */ unavailableIds?: number[]; /** * Response-only: the last saved values of chosen records the backend * confirmed as deleted. Historical, never current; an id in * `unavailableIds` without an entry here may still exist but be hidden. */ unavailableRecords?: EntityListSelectionRecord[]; } /** Whether a stored or rendered `EntityList` value is a Selected document. */ declare function isEntityListSelectionDocument(value: unknown): value is EntityListSelectionDocument; /** * One field definition of an inline `EntityList`, from its property * configuration's `inlineFields`. This is the only description of the nested * columns: the value itself carries bare keys. */ interface EntityListInlineFieldMeta { key: string; viewType?: string; order?: number; required?: boolean; configuration?: EntityPropertyConfiguration; } /** * Catalog metadata for a property nested inside another property's value. * Mirrors the top-level catalog property shape, which the backend sends under * `catalog.nestedProperties` keyed by the owning property key. Only * `LookupModuleCheckList` values carry nested properties today. */ interface EntityNestedPropertyMeta { id?: number; key: string; normalizedKey?: string; label: string; viewType: EntityViewType; configuration?: EntityPropertyConfiguration; order?: number; } interface EntityData { id?: number; propertyId?: number; key?: string; normalizedKey?: string; name?: string; rawValue?: string; /** * The colour the backend resolved for *this value*, from the value cell's own * `color` field. * * Distinct from `configuration.color`, which is a colour the configuration * declares for every value alike. This one is per-record: the backend * evaluates a Percentage property's colour rules — or, in `property` mode, * the record's colour-bearing source property — and ships the winner here. * It is therefore the most specific answer available and outranks anything * derived from the configuration. * * Status and Lookup cells repeat the same colour inside `value`, which is * where those renderers already read it; a Percentage's `value` is a * formatted string with nowhere to hang a colour, which is why this exists. */ color?: string; order?: number; /** * Marks a value the backend calculates: `mt-entity-preview` shows the * calculated-value icon beside its label. Set by the host that maps the * catalog, so a surface that does not set it renders exactly as before. */ calculated?: boolean; /** Set while the value is being recalculated: the icon pulses. */ calculationStatus?: EntityCalculationStatus | null; /** The last change to this calculated value since the record was opened. */ calculationChange?: EntityCalculationChange | null; /** * The record a calculated value was read from. When set, clicking the * calculated-value icon shows how the saved value was calculated. */ calculationSource?: EntityCalculationSource | null; propertyConfiguration?: EntityPropertyConfiguration; /** * Catalog metadata for the properties captured inside `value`. The stored * checklist value only carries property keys, so without this the nested * props have no label and no view type to render with. */ nestedProperties?: EntityNestedPropertyMeta[]; value: string | EntityTranslatableTextValue | EntityStatusValue | EntityUserValue | EntityMultiUserValue | EntityLookupValue | EntityMultiLookupValue | EntityPhaseGateValue | EntityPerformanceScoreValue | EntityAttachmentValue | EntityLocationValue | EntityConnectionValue | EntityScheduleItemValue[] | EntityLookupCheckListValue | EntityLookupCheckListItem[] | LeafDetailsEntityValue | LeafDetailsEntityCollectionValue | LeafDetailsRuntimeValue | EntityListEntityValue; viewType: EntityViewType; type?: string; configuration?: EntityConfiguration; /** Present on submitted ChangeRequest records — frozen old→new snapshot. */ comparison?: PropertyValueComparison; /** * The record's runtime ids, set by a host that renders the value outside * any `EntityRuntimeContextStore` — a table cell. `EntityList` reads it to * render its full list in the drawer, as a record preview does inline. */ runtimeContext?: EntityRuntimeContext | null; } /** Emitted when an entity is resized via the drag handle */ interface EntityResizeEvent { entity: EntityData; previousSize: EntitySize; newSize: EntitySize; } declare const ENTITY_EMPTY_VALUE_PLACEHOLDER = "_"; /** * The `grid-row` value for an entity's `configuration.rowSpan`, or `null` for * the default single row so the grid's normal auto-placement is untouched. */ declare function resolveEntityGridRow(configuration: EntityConfiguration | undefined): string | null; declare function isValueMissing(value: unknown): boolean; /** * Serializes a backend `raw` cell into the string `EntityData.rawValue` holds. * * Object raws — the Connection payload, the LeafDetails summary — must be * JSON-encoded: `String(obj)` yields "[object Object]" and silently destroys * the payload the display layer needs to expand them. Primitives keep plain * `String()` so dates/percentages/checkboxes are not wrapped in quotes. */ declare function serializeEntityRawValue(raw: unknown): string | undefined; /** * Reads the colour the backend resolved for a value cell. * * The cell carries it as a sibling of `raw`/`value` — `{ raw: "22", value: * "22%", color: "#FF0000" }` — because for a Percentage the value is a * formatted string with nowhere to hang a colour on. Status and Lookup cells * repeat it inside `value`, where those renderers already read it. * * Typed as `unknown` on purpose: every fetch-cell interface in the consuming * packages carries an index signature, so a mistyped or absent `color` is a * runtime possibility rather than a compile error. */ declare function readEntityValueColor(color: unknown): string | undefined; declare function displayOrPlaceholder(value: unknown): string; /** * Text/LongText values are a plain string, except for translatable * properties, where the backend sends `{ display, ar?, en? }` instead. * Unwraps either shape to the string to render. */ declare function extractDisplayText(value: unknown): string | null; declare function isEntityLabelHidden(configuration?: EntityConfiguration | null): boolean; declare function isEntityAlignEnd(configuration?: EntityConfiguration | null): boolean; /** * The admin-authored note attached to a property in the customization drawer * (`configuration.info`), resolved for the active language. * * Returns `''` when there is no note, which is what the renderer keys off to * decide whether the entity gets an info affordance at all. The drawer omits * the key entirely rather than writing an empty object, so "absent" and "blank" * collapse to the same answer here on purpose. */ declare function resolveEntityInfo(configuration?: EntityConfiguration | null, lang?: string): string; /** * The product default: label above value. * * It used to be `bottom`, which is why Portfolio and Program cards rendered * "06/07/2026" then "Start Date" while Project cards — whose properties had * been through the property-configuration drawer, and so carry an explicit * `labelPosition` — rendered the label first. Two orders inside one Explore * module, reachable by clicking a different item in the same sidebar * (finding M-13). Label-first reads better down a column of mixed field types, * so it is what every unconfigured property now gets. * * An explicit configuration still wins: an administrator who deliberately * chose value-above-label for a property keeps it. */ declare function resolveEntityLabelPosition(configuration?: EntityConfiguration | null): EntityLabelPosition; /** * Rewrites a localised numeric string into something `parseFloat` can read. * * `rawNumericValue` can fall back to the already-formatted display string, so * whatever `Intl.NumberFormat` produced has to survive a round trip. Under * `ar` that is harmless (Latin digits plus invisible direction marks), but * `ar-SA` renders Arabic-Indic digits and an Arabic decimal separator, which * parse to NaN — the bar would silently disappear rather than show a value. * * Handles Arabic-Indic (U+0660-0669) and Eastern Arabic-Indic (U+06F0-06F9) * digits, the Arabic decimal separator, thousands separators, and the * bidirectional marks Intl inserts around the percent sign. */ declare function normalizeNumerals(input: string): string; interface StakeholderNameColumn { key: string; normalizedKey?: string; } /** Stakeholder cards show the two mutually exclusive names in one name slot. */ declare function mergeStakeholderNameEntities(entities: EntityData[]): EntityData[]; /** Hide the duplicate only when both stakeholder name fields are displayed. */ declare function mergeStakeholderNameColumns(columns: T[]): T[]; /** Presentation only: retain the original cells and row edit/submission maps. */ declare function mergeStakeholderNameRows>(columns: StakeholderNameColumn[], rows: T[]): T[]; type EntityFieldGap = 'compact' | 'normal' | 'relaxed'; declare class EntityField { private readonly previewData; readonly calculated: _angular_core.Signal; readonly calculationStatus: _angular_core.Signal<_masterteam_components_entities.EntityCalculationStatus | null | undefined>; readonly calculationChange: _angular_core.Signal<_masterteam_components_entities.EntityCalculationChange | null | undefined>; /** What the calculated-value mark explains on click, if anything. */ readonly calculationExplanation: _angular_core.Signal<_masterteam_components_entities.EntityCalculationExplanationTarget | null>; readonly recentChange: _angular_core.Signal<_masterteam_components_entities.EntityCalculationChange | null>; readonly label: _angular_core.InputSignal; readonly labelIconName: _angular_core.InputSignal; readonly configuration: _angular_core.InputSignal; readonly gap: _angular_core.InputSignal; readonly hideLabel: _angular_core.Signal; readonly labelPosition: _angular_core.Signal<_masterteam_components_entities.EntityLabelPosition>; readonly labelContainerClass: _angular_core.Signal; readonly contentContainerClass: _angular_core.Signal; readonly containerClass: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityText { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** * Renders without the field wrapper, which only carries the label, unless * the wrapper has a chip to show beside the value: how a calculated value * just changed. The wrapper hides the label itself. */ protected readonly bare: _angular_core.Signal; protected readonly alignEnd: _angular_core.Signal; readonly displayValue: _angular_core.Signal; protected readonly hasMarkup: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityDate { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly viewType: _angular_core.InputSignal<"Date" | "DateTime" | "Time">; readonly displayName: _angular_core.Signal; /** * `Time` carries a wall-clock value (`HH:mm:ss`) with no date and no zone, so * `mtDateFormat` renders it as stored instead of shifting it into the * viewer's timezone the way its `DateTime` sibling is shifted. */ readonly resolvedViewType: _angular_core.Signal; readonly displayValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityStatus { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly statusValue: _angular_core.Signal; readonly badgeStyle: _angular_core.Signal<{ color?: undefined; backgroundColor?: undefined; } | { color: string; backgroundColor: string; }>; readonly emptyLabel = "_"; readonly statusLabel: _angular_core.Signal; private hexToRgba; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Renders an `Icon` view-type value — a stored icon key such as * `custom.strategy` — as the actual glyph via `mt-icon`, rather than printing * the raw key as text (which is what the plain-text fallback used to do before * `Icon` was a distinct view type). */ declare class EntityIcon { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly emptyLabel = "_"; readonly iconName: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Renders a `Color` view-type value — a stored `#rrggbb` string — as a swatch * next to its hex code, rather than printing the code alone. */ declare class EntityColor { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly emptyLabel = "_"; readonly color: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityUser { readonly httpContext: HttpContext; /** Full entity data object */ readonly data: _angular_core.InputSignal; readonly expanded: _angular_core.WritableSignal; readonly displayName: _angular_core.Signal; readonly isMultiUser: _angular_core.Signal; /** Resolved user objects from either a User or MultiUser entity value. */ readonly users: _angular_core.Signal; readonly maxVisibleUsers: _angular_core.Signal; readonly visibleUsers: _angular_core.Signal; readonly hiddenUserCount: _angular_core.Signal; /** First user retained for the existing single-user computed API. */ private readonly userValue; userNameFor(user: EntityUserValue): string; userPhotoFor(user: EntityUserValue): string; labelTextFor(user: EntityUserValue): string; isUnlinkedUser(user: EntityUserValue): boolean; phoneNumberFor(user: EntityUserValue): string; emailFor(user: EntityUserValue): string; hasContactInfoFor(user: EntityUserValue): boolean; readonly emptyUserName: _angular_core.Signal; readonly rawUserName: _angular_core.Signal; readonly userName: _angular_core.Signal; readonly userPhoto: _angular_core.Signal; readonly labelText: _angular_core.Signal; /** * `true` when the referenced user is no longer linked to the application. * Drives the inline info badge/tooltip next to the display name. */ readonly isUnlinked: _angular_core.Signal; private readonly config; readonly showDisplayName: _angular_core.Signal; readonly showPhoneNumber: _angular_core.Signal; readonly showEmail: _angular_core.Signal; /** When off the avatar is dropped entirely, leaving the name on its own. */ readonly showAvatar: _angular_core.Signal; readonly phoneNumber: _angular_core.Signal; readonly email: _angular_core.Signal; readonly hasContactInfo: _angular_core.Signal; constructor(); showAllUsers(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityPercentage { private readonly transloco; /** Active locale, so number formatting follows the UI language. */ private readonly locale; /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly rawValue: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** What the calculated-value mark explains on click, if anything. */ readonly calculationExplanation: _angular_core.Signal<_masterteam_components_entities.EntityCalculationExplanationTarget | null>; readonly displayValue: _angular_core.Signal; private readonly rawNumericValue; readonly hasNumericValue: _angular_core.Signal; readonly numericValue: _angular_core.Signal; readonly maxValue: _angular_core.Signal; readonly hideName: _angular_core.Signal; /** * The bar colour. The backend evaluates the property's colour rules and * returns the winner as `color` on render/value/fetch responses, so a * resolved colour always wins — the rules are only evaluated here for * configurations that arrive without one (a catalog read, or the * property-form preview). * * The value's own `color` is checked first and is not the same thing as * `configuration.color`: it is resolved per record, so it is the only one * that can carry a band colour for *this* value, or the colour a * `colorSource: 'property'` configuration took from a sibling property on * this record. A configuration-level colour applies to every value alike and * cannot answer either question. */ readonly progressColor: _angular_core.Signal; /** * Renders a percentage for the active locale. * * This used to echo the backend's string and only append `%` when that string * already carried one — so in Arabic, where the API returns a bare `"25"`, * the symbol vanished and a progress value rendered as an unlabelled `25`. * Next to a bar that could be a percentage, a count or a score (finding * H-08). * * Formatting from the NUMBER through `Intl.NumberFormat` makes the symbol, * the decimal separator and the digit shapes follow the locale instead of the * payload. `maximumFractionDigits: 1` preserves the precision the old code * kept; `style: 'percent'` expects a fraction, hence the /100. * * Non-numeric values pass through untouched — a status string or an em dash * must not be mangled into `NaN%`. */ private formatPercentageDisplay; private parseNumericValue; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityCurrency { private readonly transloco; /** Active locale, so number formatting follows the UI language. */ private readonly locale; /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** The backend's fully grouped string — always the tooltip, never truncated. */ readonly fullValue: _angular_core.Signal; /** * What the cell renders: the backend's string, or a compact form of it when * the amount is large enough that the currency token would be truncated away. * See {@link compactCurrencyDisplay} (finding H-06). */ readonly displayValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityCheckbox { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly rawValue: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** What the calculated-value mark explains on click, if anything. */ readonly calculationExplanation: _angular_core.Signal<_masterteam_components_entities.EntityCalculationExplanationTarget | null>; readonly emptyLabel = "_"; readonly hideName: _angular_core.Signal; readonly checkboxState: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityLongText { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly displayValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityLookup { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly lookupValues: _angular_core.Signal; lookupBadgeStyle(lookup: EntityLookupValue): Record; readonly emptyLabel = "_"; lookupLabel(lookup: EntityLookupValue): string; private hexToRgba; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Badge color used when the phase gate carries no `color`. `color` is optional * presentation metadata, so a phase gate without one must still read as a * badge rather than as bare text — this is the same neutral slate the table * falls back to for uncategorized status chips. */ declare const DEFAULT_PHASE_GATE_COLOR = "#475569"; /** * Preview renderer for `PhaseGate` properties — a calculated, read-only lookup * pointing at the schema phase gate the record currently sits on. It renders * exactly like {@link EntityLookup} (colored badge) but resolves its label * per-language. * * Label resolution, in order: * 1. `value.ar` / `value.en` for the active language — the backend sends both * so a client-side language switch re-renders without a refetch, which is * why they win over the already-resolved `display`. * 2. `value.display`, then the other locale. * 3. The flat display, for payloads that send the value as a bare string * (comparison snapshots build their sides that way). * 4. `rawValue` — the schema phase-gate id — as a last resort. */ declare class EntityPhaseGate { private readonly transloco; /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; private readonly activeLang; readonly displayName: _angular_core.Signal; readonly phaseGateValue: _angular_core.Signal; /** Resolved label, or `null` when nothing at all is available. */ private readonly resolvedLabel; readonly hasValue: _angular_core.Signal; readonly phaseGateLabel: _angular_core.Signal; readonly badgeStyle: _angular_core.Signal<{ color: string; backgroundColor?: undefined; } | { color: string; backgroundColor: string; }>; readonly emptyLabel = "_"; /** The value flattened to a plain display string by the sender. */ private flatDisplay; /** The schema phase-gate id. */ private rawId; private hexToRgba; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface GaugeBand { key: string; path: string; color: string; opacity: number; } interface GaugeLabel { key: string; text: string; x: number; y: number; anchor: 'start' | 'middle' | 'end'; } /** * Preview renderer for `PerformanceScore` properties — a KPI's performance as a * semicircle gauge, ported from SPlus v3's `app-performance-gauge`. * * Each status band is an arc segment; the band the score sits in is drawn at * full strength and the rest are faded. The marker rides the arc at the score, * the score itself sits in the middle, and the current status is a pill below. * * Geometry is computed, not measured: the SVG has a fixed `viewBox` and * `width: 100%` (capped by `configuration.chartSize`, centred), so it scales with its grid * cell without a `ResizeObserver` — a card grid mounts one of these per record. */ declare class EntityPerformanceScore { private readonly activeLang; /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** The display configuration's `chartSize`, as a CSS `max-width`. */ readonly chartMaxWidth: _angular_core.Signal; readonly scoreValue: _angular_core.Signal; readonly performance: _angular_core.Signal; readonly hasPerformance: _angular_core.Signal; /** Bands with at least one bound, ordered along the arc. */ private readonly statuses; /** 0–100, widened to the outermost band bound. */ private readonly scale; /** See {@link resolvePerformanceScoreStatus}; the table filters by it too. */ readonly status: _angular_core.Signal; readonly accentColor: _angular_core.Signal; readonly bands: _angular_core.Signal; /** A label at every band start except the gauge minimum. */ readonly labels: _angular_core.Signal; /** * The drawn extent — arc, marker and band labels — in viewBox units. Fitted * tightly on every side: a label that overhangs one end of the arc is not * mirrored as empty space on the other, which used to leave the gauge with a * visibly wider gap on one side of its cell. */ private readonly frame; readonly viewBox: _angular_core.Signal; /** * Horizontal padding (percent of the gauge width) that centres the status * pill under the arc's centre rather than under the SVG's, which drifts off * it whenever a band label overhangs only one end of the arc. */ readonly pillInset: _angular_core.Signal<{ left: number; right: number; }>; readonly marker: _angular_core.Signal<{ x: number; y: number; } | null>; readonly performanceLabel: _angular_core.Signal; readonly statusLabel: _angular_core.Signal; /** Same tinted badge as `mt-entity-status`, so both read as one status. */ readonly statusPillStyle: _angular_core.Signal<{ color: string; backgroundColor: string; }>; /** Score → position along the arc, clamped to its ends. */ private toFraction; /** Arc fraction → angle; 0 is the left end, 1 the right. */ private toAngle; private pointAt; private arcPath; /** Same locale-aware formatting as `mt-entity-percentage`. */ private formatPercent; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Shared reading of a `PerformanceScore` value. The gauge draws from it and the * table resolver filters by it, so a card's pill and the filter it sets can * never disagree about which status a record is in. */ /** Every `chartSize`, smallest first — the order the drawer offers them in. */ declare const PERFORMANCE_SCORE_CHART_SIZES: readonly EntityPerformanceScoreChartSize[]; /** The cap applied when a display configuration carries no `chartSize`. */ declare const DEFAULT_PERFORMANCE_SCORE_CHART_SIZE: EntityPerformanceScoreChartSize; /** The score as a number, or `null` when there is no measurement. */ declare function parsePerformanceScore(raw: unknown): number | null; /** Bands with at least one bound, ordered along the arc. */ declare function getPerformanceScoreBands(value: EntityPerformanceScoreValue | null | undefined): EntityPerformanceScoreStatus[]; /** * The backend's status, else the band whose range holds the score. A missing * bound is open-ended here — unlike on the arc, where it stops at the scale — * so a 120% score still lands in a `from: 95` band. */ declare function resolvePerformanceScoreStatus(value: EntityPerformanceScoreValue | null | undefined): EntityPerformanceScoreStatus | null; type AttachmentReference = EntityAttachmentItemValue | string; declare class EntityAttachment { readonly data: _angular_core.InputSignal; readonly name: _angular_core.InputSignal; readonly shape: _angular_core.InputSignal<"default" | "compact">; readonly value: _angular_core.InputSignal; readonly endPoint: _angular_core.InputSignal; readonly context: _angular_core.InputSignal; private readonly httpClient; private readonly transloco; readonly displayName: _angular_core.Signal; readonly loading: _angular_core.WritableSignal; readonly attachments: _angular_core.WritableSignal; /** Key of the compact chip currently hovered, so it can reveal the download affordance. */ readonly hoveredAttachmentKey: _angular_core.WritableSignal; readonly attachmentReferences: _angular_core.Signal; readonly uploadValue: _angular_core.Signal; readonly hasAttachments: _angular_core.Signal; readonly isMultiple: _angular_core.Signal; readonly acceptTypes: _angular_core.Signal; protected readonly empty = "-"; constructor(); attachmentTrackBy(index: number, attachment: EntityAttachmentItemValue): string; attachmentTooltip(attachment: EntityAttachmentItemValue): string; /** * Compact chips are clickable downloads but only show a file-type glyph, * which doesn't read as actionable. Swap to a download icon while hovered * so the action is obvious. */ attachmentActionIcon(index: number, attachment: EntityAttachmentItemValue): MTIcon; attachmentIcon(attachment: EntityAttachmentItemValue): MTIcon; onCompactAttachmentClick(event: MouseEvent, attachment: EntityAttachmentItemValue): void; downloadAttachment(attachment: EntityAttachmentItemValue): void; private resolveAttachment$; private normalizeAttachmentValue; private normalizeAttachmentItem; private requiresMetadataRequest; private isAttachmentItemValue; private resolveExtension; private normalizeAcceptTypes; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityLocation { readonly data: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly location: _angular_core.Signal; readonly displayValue: _angular_core.Signal; readonly coordinates: _angular_core.Signal; readonly mapsUrl: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityConnection { /** Full entity data object */ readonly data: _angular_core.InputSignal; /** Individual inputs (used when data is not provided) */ readonly name: _angular_core.InputSignal; readonly value: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; /** The connection display lives on `rawValue.display`; fall back to `value`. */ readonly connection: _angular_core.Signal; readonly displayValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Preview renderer for `ScheduleItemSelector` properties. * * The value is the array of resolved schedule items returned by runtime * rendering (`{ id, name, status, ... }`); each one is shown as a chip. */ declare class EntityScheduleItem { /** Full entity data object */ readonly data: _angular_core.InputSignal; readonly displayName: _angular_core.Signal; readonly items: _angular_core.Signal; readonly emptyLabel = "_"; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** One rendered row of an `EntityList` value: a title plus the rest. */ interface EntityListRenderedRow { id: string; /** First field by order — the row's own name. */ title: EntityData | null; /** Everything else, already stripped of machine companions. */ fields: EntityData[]; } /** * Derive a readable label from a raw field key. Inline `EntityList` fields * carry no label of their own — the configuration defines them as bare keys — * so this strips separators and title-cases what is left. */ declare function humanizeEntityListKey(key: string): string; /** * Turns an `EntityList` entity into rendered rows. * * Nothing is fetched: the value already carries `rows[]`, and the property * configuration's `inlineFields` is the only description of the nested columns * — the rows themselves carry bare keys. Shared by the trigger * (`mt-entity-list-preview`, which needs the count and the titles) and the * drawer that renders them in full. * * `allowed` narrows to those keys, in that order; empty renders every field * that survives the companion and identifier rules. */ declare function buildEntityListRows(data: EntityData, allowed?: readonly string[], lang?: string): EntityListRenderedRow[]; /** * Plain-text summary of the rows, for the trigger's tooltip. Caps the list so * a forty-item checklist does not become a forty-line tooltip. */ declare function summarizeEntityListRows(rows: readonly EntityListRenderedRow[], limit: number): { names: string[]; remaining: number; }; /** * Pure helpers shared by everything that reads a Local `EntityList` * (`storageMode: "Local"`) — the runtime field that edits it and the preview * that only renders it. See `.github/instructions/properties/EntityList.md`. */ /** * The schema's fields a row is rendered with, in order. * * A removed field stays in the stored schema as `hidden` so its values survive * and come back if it is re-added. The projected schema of a loaded value has * already dropped them, but the configuration's copy — what a create form falls * back to — has not. */ declare function visibleLocalSchemaFields(schema: EntityListLocalSchema | null | undefined): EntityListLocalSchemaField[]; /** * The label a field renders under: its local override, then the source label * captured when it was published, then its key. The publisher writes an * override into the captured definition as well, so either path shows it. */ declare function resolveLocalFieldLabel(field: EntityListLocalSchemaField, lang?: string): string; /** The source view type the field captured; `Text` when none was. */ declare function resolveLocalFieldViewType(field: EntityListLocalSchemaField): string; /** * The captured source configuration (lookup id, percentage colour rules …). * `PropertyDefinitionReadDto.configuration` is typed `object?`, so the backend * writes whatever the source held — an object, or its JSON text. */ declare function resolveLocalFieldConfiguration(field: EntityListLocalSchemaField): Record | null; /** A row's cells keyed by field id. */ declare function localCellsByFieldId(row: EntityListLocalRow): Map; /** Rows in their stored order. */ declare function sortLocalRows(rows: readonly EntityListLocalRow[] | null | undefined): EntityListLocalRow[]; /** * What `NgComponentOutlet` needs to render an `EntityList` table: the * read-only `mt-entity-list-field` (`ENTITY_LIST_TABLE_COMPONENT`) and its * inputs. */ interface EntityListTableHost { component: Type; inputs: Record; } /** * The full nested `EntityList`, rendered in a drawer opened by * `mt-entity-list-preview`. * * It lives in a drawer rather than in the cell because the cell is a table * column: even three lines per row set the height of every row in the table, * and a checklist of fifteen made the grid unreadable. The drawer has the * width and height this content actually needs. * * With a `table` it renders the list the way a record preview does — the * read-only `mt-entity-list-field`, with its columns, typed cells and access * notices — for a table cell whose host knew the record's runtime ids. * Otherwise it renders the rows the value itself carries. * * Created through `ModalService`, so its inputs arrive via `inputValues` and * it is built with the **root** injector — nothing route-provided is visible * here, which is why it takes the already-resolved entity and table rather * than looking anything up. */ declare class EntityListDrawer { readonly data: _angular_core.InputSignal; /** Ordered allowlist of nested field keys; empty renders all of them. */ readonly fields: _angular_core.InputSignal; /** The list's table, when the opener could build one; see above. */ readonly table: _angular_core.InputSignal; /** A Local list's labels are `{ en, ar }` pairs; see `sharedActiveLang`. */ private readonly activeLang; readonly rows: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Read-only renderer for an `EntityList` value. It has two shapes, and which * one applies is decided by what the host gave it — never by the value. * * **Inline table.** When the host published an `EntityRuntimeContext` and the * property is module-backed, the rows are the target module's own records and * live behind `Properties/{id}/entitylist/table-metadata` + `fetch/query`. * Nothing in the value describes them — a `Realtime` list's value is literally * `null` — so the whole table is fetched, by handing the work to the read-only * `mt-entity-list-field` through `ENTITY_LIST_TABLE_COMPONENT`. That component * already owns the metadata call, the authorization boundary (`403` is a * notice, not an error) and the column projection; duplicating it here would * be a second implementation of the same contract. This is the shape a card * preview gets. * * **Count + drawer.** Otherwise the value carries its own `rows[]` and the * property configuration's `inlineFields` is the only description of the * columns — a calculated inline list, phase gate checklists being the case * this was written for. Those render inside a *table cell* (`mt-table` builds * its entity cells through `mt-entity-preview`), where inline rows would own * the height of every row in the grid: three lines per checklist item, times * however many the phase gate has. The rows go in a drawer instead, and the * tooltip names them so "which ones are these?" is answered without opening * anything. A table cell publishes no runtime context, so it keeps this shape. * * There is no writable path in either case. */ declare class EntityListPreview { readonly data: _angular_core.InputSignal; /** * Restricts rendering to these nested field keys, in this order. Left empty, * every field in `inlineFields` renders — what the generic table path wants; * a host that knows the list narrows it here. Forwarded to the drawer. * * Applies to the drawer shape only: an inline table's columns come from the * backend's own projection, which already reflects the configured read * fields for this level. */ readonly fields: _angular_core.InputSignal; private readonly modal; private readonly transloco; /** * Both optional, and both have to be present for the inline table: the * component says the host *can* render one, the context says it knows which * level-data row to scope the rows to. A host that provides neither — every * `mt-table` cell — keeps the drawer. */ private readonly tableComponent; private readonly runtimeContextStore; /** * Read inside every computed that translates. `transloco.translate()` is a * one-shot read with no signal of its own, so without this dependency the * tooltip and the accessible name keep whatever language they were first * built in — both apps switch language at runtime. Shared rather than a * per-instance subscription: this renders once per cell per row. */ private readonly activeLang; readonly label: _angular_core.Signal; readonly rows: _angular_core.Signal; readonly count: _angular_core.Signal; readonly hasRows: _angular_core.Signal; /** * Whether the list's rows are records of another module rather than values * held inside this one. * * Mirrors the backend's own `ResolveSourceType`: an explicit `sourceType` * wins, and a configuration written before that field existed is module- * backed exactly when it names a module. Read from the stored configuration * because it is the only description available before the metadata request — * the effective, level-overridden one comes back from that endpoint, and the * table component gates on it again. */ private readonly moduleBacked; /** * The inline table's component and inputs, or null when this instance * renders the drawer trigger instead. * * A `computed` rather than a template expression on purpose: the object is * re-created only when its inputs actually change, and `NgComponentOutlet` * re-applies inputs on identity change — a fresh object per change-detection * pass would re-write every input on every tick. */ protected readonly tableHost: _angular_core.Signal; /** * The same table, for the drawer of a table cell. A cell publishes no * runtime context — an inline table would set the height of every row — but * a host that knows the record's ids puts them on the value * (`EntityData.runtimeContext`), and the drawer then shows the list exactly * as a record preview does, instead of the value-only rows. */ private readonly drawerTable; private buildTableHost; /** * Whether the value itself holds the list's rows — a Local or Selected * document. A Related list's value is membership and evidence only; its * rows are read by the table, so its cell does not claim a count. */ private readonly valueHoldsRows; /** The trigger shows when there are rows to count, or a table to open. */ protected readonly showTrigger: _angular_core.Signal; /** * The trigger's label: the row count when the value holds the rows, else * "View" — a Related list's saved membership is not what its table shows, * so it is not presented as a count. */ protected readonly triggerLabel: _angular_core.Signal; /** * An empty list reads as the standard empty value, not as a sentence — this * sits in a table cell, where a "no related items" line would be louder than * the rows it stands in for. */ readonly emptyLabel: string; /** * The button's accessible name. Set explicitly because `mt-button` resolves * it as `ariaLabel → label → tooltip`, and the label here is the bare count * — a screen reader would otherwise announce the button as "2". */ readonly ariaLabel: _angular_core.Signal; /** * Names the rows, so the cell answers "which ones?" on hover. Falls back to * the button's own wording when no row has a title to show. */ readonly tooltip: _angular_core.Signal; /** * The untouched catalog configuration. `configuration` is read as a fallback * because the table merges its own display flags into that object when it * builds a cell, and a `LeafDetails` catalog entry is an array — neither is * an `EntityList` configuration, so both are rejected here. */ private readonly propertyConfiguration; private viewLabel; protected openDrawer(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface RenderedItem { lookupKey: string; /** Humanized lookup key for display. */ lookupLabel: string; /** One entity per captured property, rendered by its catalog view type. */ props: EntityData[]; } declare class EntityLookupModuleCheckList { readonly data: _angular_core.InputSignal; /** * Catalog metadata for the captured properties, keyed by property key. The * stored value carries keys only — this is what gives each nested prop its * label and view type. */ private readonly metaByKey; /** * Normalizes the stored value into a flat list of checklist entries. * Accepts both the rendered view model (`{ items: [...] }`) and the raw * stored array (`[{ lookupKey, props }]`); returns `[]` for anything else. */ readonly items: _angular_core.Signal; readonly hasItems: _angular_core.Signal; readonly emptyLabel: string; /** * Builds the entity for one captured property. Without catalog metadata the * key is all there is to show it with, so it degrades to a humanized label * and plain text. */ private toNestedEntity; private extractEntries; private resolveLookupKey; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityLeafDetails { private readonly transloco; readonly data: _angular_core.InputSignal; /** * Re-resolves the "Phases" qualifier when the user switches language. The * shared signal keeps this to one subscription for the whole grid — a cards * board mounts thousands of these. */ private readonly activeLang; readonly leafValue: _angular_core.Signal; /** True when this item paints the level's phase badges instead of statuses. */ readonly isPhaseItem: _angular_core.Signal; /** * This tile's own saved overrides — the `leafLevels` / `leafPhases` entry for * its child level. The two maps are kept apart because one level can render * both projections, each with its own slot, width and now label. */ private readonly tileConfig; /** * The badges to paint. Phases and statuses carry the same `{ key, display, * color, count }` shape, so one template drives both — only which projection * of the level is read differs. */ readonly badges: _angular_core.Signal; /** * Label shown below the badges: "Level Name (total)", with a "— Phases" * qualifier on an unnamed phase item so a level configured with both * projections does not render two identically-labelled tiles. * * The custom label is read off the tile's OWN per-level entry, not from * `data().name` and not from the parent property's `configuration.label`. * * Not `name`, because for this view type it does not survive the trip: both * hosts resolve a label into `name` up front (`toEntityData` in * client-instance-preview, `openDrawer` in the customization builder), and * then `expandLeafDetailsEntity` rewrites `name` to the child level's own * name when it splits the property into one tile per level. * * Not the parent's label, because one property becomes many tiles — one per * child level, and again per projection. A label held on the parent paints * the same text on every one of them, which is what makes a card show * "Delivery Portfolio (7)" three times over. `order` and `size` were already * per-level for exactly this reason; the label follows them. * * A custom label owns the whole name. The "— Phases" qualifier is only the * *default* disambiguator for a level that renders both projections — once an * author names the phase tile themselves, appending it would force a suffix * onto text they wrote, and "Delivery Stages — Phases" is not something they * can spell their way out of. So the qualifier applies to the fallback name * only; the author is trusted to have distinguished the tile. * * `(total)` is the one thing always appended — the count is the point of the * tile, and it is live data, not part of anyone's label. */ readonly labelWithTotal: _angular_core.Signal; readonly labelIcon: _angular_core.Signal; statusColor(color: string | null): string; /** * Foreground for the count, chosen against the badge colour instead of always * white — a light catalog colour measured 2.59:1 with white on it, the lowest * contrast in the product (findings M-04, H-03). */ statusTextColor(color: string | null): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare const LEAF_DETAILS_KEY_SEPARATOR = "::leaflevel::"; /** * The phase projection of the same child level. One level can contribute both * a status item and a phase item to the same area, so they need distinct keys * — the key is what each item's persisted order/size is looked up by. */ declare const LEAF_PHASES_KEY_SEPARATOR = "::leafphase::"; declare function isLeafDetailsValue(value: unknown): value is LeafDetailsEntityValue; declare function isLeafDetailsCollectionValue(value: unknown): value is LeafDetailsEntityCollectionValue; declare function isLeafDetailsCatalogConfiguration(value: unknown): value is LeafDetailsCatalogConfiguration; declare function isLeafDetailsRuntimeValue(value: unknown): value is LeafDetailsRuntimeValue; declare function isLeafDetailsSyntheticKey(key?: string | null): boolean; /** True for the key of an expanded *phase* item of a LeafDetails property. */ declare function isLeafPhasesSyntheticKey(key?: string | null): boolean; /** True for either projection's expanded key. */ declare function isLeafSyntheticKey(key?: string | null): boolean; /** Splits either projection's expanded key back into property key + level id. */ declare function splitLeafKey(key: string): { propertyKey: string; levelId: string; kind: 'status' | 'phase'; }; declare function expandLeafDetailsEntity(entity: EntityData): EntityData[]; /** * Expands the entity types that render as several items — LeafDetails levels * and Connection source levels — then orders the flattened list, with the card * header (if any) pinned first. Shared by the customization builder canvas and * the runtime preview so both agree on what a configured area actually * contains. */ declare function buildDisplayEntities(entities: EntityData[]): EntityData[]; /** * Separator for the synthetic keys of the per-source-level items a Connection * property expands into. Mirrors `LEAF_DETAILS_KEY_SEPARATOR`: the persisted * display configuration is still keyed by the real property key, and the split * items only exist in the rendered/managed entity list. */ declare const CONNECTION_KEY_SEPARATOR = "::connlevel::"; declare function isConnectionSyntheticKey(key?: string | null): boolean; declare function buildConnectionKey(propertyKey: string, levelId: number | string): string; /** Splits a synthetic key back into the owning property key and its level id. */ declare function splitConnectionKey(key: string): { propertyKey: string; levelId: string; }; /** * Reads the `sourceLevels` published on a Connection property's catalog * configuration. These define the split — one item per source level — and carry * the level name used as each item's label. */ declare function normalizeConnectionSourceLevels(configuration: unknown): ConnectionSourceLevelConfig[]; /** Picks the source level's localized name for the active document language. */ declare function resolveConnectionLevelName(level: ConnectionSourceLevelConfig): string; /** * Splits a Connection entity into one item per source level, so a card shows * each connected level under its own name instead of a single comma-joined * value under the generic "Connection" label. * * Falls back to the original entity when the catalog publishes no source * levels — without them there is nothing to label the split items with. */ declare function expandConnectionEntity(entity: EntityData): EntityData[]; /** * The largest amount still rendered in full. * * The reviewer measured exactly where the line falls: `100,000 SAR` fits a card * slot, `1,000,000 SAR` does not and loses its currency to the ellipsis. So the * comparison below is inclusive — anything ABOVE this compacts, and everything * a tenant sees today at or under it is untouched. */ declare const CURRENCY_COMPACT_THRESHOLD = 100000; /** * The numeric amount inside a formatted currency string. * * Strips the currency token, the grouping separators and the bidirectional * marks `Intl` leaves around them, and normalises Arabic-Indic digits so an * `ar-SA` payload parses like an `en` one. `null` when there is no number. */ declare function parseCurrencyAmount(raw: string | null | undefined): number | null; /** * Whatever is left of a formatted amount once the number is removed — `SAR`, * `ر.س`, `$`. Read from the payload rather than configured, so a tenant's own * currency survives untouched. */ declare function currencyUnitOf(formatted: string): string; /** * A large currency amount shortened so it fits a card slot, with the unit kept. * * A budget of a million or more used to render as `1,000,000 …`: the digits * survived the ellipsis and the currency did not, so the largest and most * consequential figures in the product were the only ones whose unit could not * be read (finding H-06). Compact notation keeps the whole thing inside the * slot — `SAR 1M` instead of `1,000,000 SAR` — and callers put the exact figure * in a tooltip, which is where a precise number belongs on a summary card. * * Returns `formatted` unchanged whenever the value already fits, is not a * number, or the runtime has no compact notation — so no tenant sees an * existing number change shape for no reason. */ declare function compactCurrencyDisplay(formatted: string, rawValue: string | null | undefined, locale: string, threshold?: number): string; /** * How a calculated value moved between two reads of the same record, or `null` * when it did not. Numeric view types get a signed difference; anything else * only records what it read before and after. `locale` formats the exact * values used when the displayed ones round to the same text. */ declare function describeCalculationChange(previous: EntityData, current: EntityData, locale?: string): EntityCalculationChange | null; /** The signed difference as the chip shows it, e.g. `+500K SAR` or `+0.1%`. */ declare function formatCalculationDelta(change: EntityCalculationChange, locale: string): string | null; /** How long the chip beside a value that just changed stays visible. */ declare const CALCULATION_CHANGE_CHIP_MS = 30000; /** The catalog fields that decide whether a property counts as calculated. */ interface CalculatedPropertyMeta { viewType?: string | null; isCalculated?: boolean | null; calculationMethod?: string | null; } /** * Whether a surface marks this property as calculated. `isCalculated` alone is * too broad: the backend also sets it, with no calculation method, on system * columns such as `created_at`, `id` and `team_members`. A status has no method * but is recalculated. An auto code is generated rather than recalculated, but * the backend explains it like any calculated value, so it is marked too. */ declare function isCalculatedProperty(meta: CalculatedPropertyMeta | null | undefined): boolean; /** * Remembers the calculated values each surface last showed, for the whole * session, so a value that moved while the surface was closed still says so * when it opens again: the card of a project edited from its workspace, or a * preview opened a second time. * * A scope names a kind of surface, such as `preview:level:12` or * `list:level:12`. Each compares only with itself: two endpoints may not agree * at the same moment, and comparing across them would invent changes. */ declare class CalculatedValueHistory { private readonly seen; private readonly timers; private readonly changes; /** * Records the calculated values a surface just read. Those that moved since * the scope last read them get a change, shown as recent for * {@link CALCULATION_CHANGE_CHIP_MS}. */ observe(scope: string, recordId: string | number, entities: readonly EntityData[], locale: string): void; /** The last change of one value, if the scope saw it move. Reactive. */ changeOf(scope: string, recordId: string | number, propertyKey: string): EntityCalculationChange | null; /** * The entities with the last change of each calculated value attached. * Returns the same array when nothing changed, so inputs stay stable. * Reactive. */ apply(scope: string, recordId: string | number, entities: T[]): T[]; private expireLater; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** The calculated-value mark. Drawn, so it sits centred at any size. */ declare class EntityCalculatedGlyph { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Marks a property value the backend calculates. Rendered beside its label; it * pulses while a recalculation that covers the value is in progress, and stays * lit without pulsing once that is taking longer than expected. * * Given an `explanation` target it is a button: clicking it shows how the saved * value was calculated. */ declare class EntityCalculatedIndicator { /** Set while the value is being recalculated. */ readonly status: _angular_core.InputSignal; /** The value's last change, described in the tooltip when it is not busy. */ readonly change: _angular_core.InputSignal; /** The value to explain on click. Without it the mark only has a tooltip. */ readonly explanation: _angular_core.InputSignal; protected readonly popover: _angular_core.Signal; protected readonly opened: _angular_core.WritableSignal; private readonly explanationElement; constructor(); protected readonly pulsing: _angular_core.Signal; protected readonly tooltipKey: _angular_core.Signal; protected readonly tooltipParams: _angular_core.Signal<{ previous: string; current: string; } | undefined>; protected toggle(event: MouseEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Reads the latest saved calculation of a value. The request never * recalculates anything; the response is marked `no-store`, so every open * asks again. */ declare class CalculationExplanationApi { private readonly http; read(source: EntityCalculationSource, propertyKey: string): Observable; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Names the records a calculation read (schedule items, financial rows) through * the normal runtime record reads, so a contributor reads as its title rather * than its id. Only names are taken; the numbers stay the captured ones. */ declare class CalculationRecordNames { private readonly http; /** * Names by {@link calculationRecordKey}. A record the reader may not see, or * any failed read, is simply absent. */ read(owner: EntityCalculationSource, refs: CalculationRecordRef[]): Observable>; private readContext; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** `Level:1/Module:4` → `level:1/module:4`, the casing record reads use. */ declare function toFetchContextKey(contextKey: string | null): string | null; /** The key a record's name is stored under. */ declare function calculationRecordKey(contextKey: string | null, recordId: number): string; /** * The context key in the casing the endpoint accepts. Fetch contexts are * written `level:12/module:5`, but this endpoint validates `Level:12/Module:5` * case-sensitively and answers anything else with a 400. Null for a context it * does not explain. */ declare function toCalculationContextKey(contextKey: string): string | null; /** * What a value's calculated-value mark explains on click: any calculated value * (a formula, a status, a generated code, a date or an amount) whose host * named the record it was read from. */ declare function toCalculationExplanationTarget(entity: EntityData | null | undefined, label?: string | null): EntityCalculationExplanationTarget | null; /** * Lets an explanation ask the host that rendered a value to read it again, * when the saved value no longer matches the one on screen. Provided by * `mt-client-instance-preview`; without it the explanation only says so. */ declare abstract class EntityCalculationRefresher { abstract refreshStaleCalculatedValue(): void; } /** * The application's currency unit (`SAR`), shown after captured amounts. The * explanation never guesses a currency: without this token, or with an empty * unit, amounts are shown as plain numbers. */ declare const MT_CALCULATION_CURRENCY: InjectionToken>; /** * The names of a status property's statuses in a language, by status key, so * a status rule reads as its business name. Read inside a reactive context: * a host backed by signals updates the explanation when its statuses load. */ type CalculationStatusNames = (propertyKey: string, lang: string) => Record; declare const MT_CALCULATION_STATUS_NAMES: InjectionToken; declare const CALCULATION_EXPLANATION_KEYS = "components.entitiesPreview.calculationExplanation"; /** What formatting needs from the host: language, currency, dates, text. */ interface ExplanationFormatContext { lang: string; currency: string; formatDate: (value: string, type: 'date' | 'dateTime' | 'time') => string; translate: (key: string, params?: Record) => string; } /** One piece of the readable equation. Rendered as plain text, never HTML. */ type ExplanationSegment = { kind: 'text'; text: string; } | { kind: 'value'; text: string; } | { kind: 'term'; label: string; value: string | null; } | { kind: 'result'; text: string; } | { kind: 'muted'; text: string; }; /** * How an equation reads: `labels` is its shape (`Budget − Spent`), `values` * the captured values in that shape (`10,000 SAR − 125,454 SAR`), `inline` * both at once (`Budget (10,000 SAR)`), for status conditions. */ type SegmentMode = 'inline' | 'labels' | 'values'; /** Captured JSON shown as labelled data. */ type ExplanationData = { kind: 'text'; text: string; } | { kind: 'list'; items: string[]; } | { kind: 'table'; columns: string[]; rows: string[][]; more: number; } | { kind: 'fields'; fields: { label: string; data: ExplanationData; }[]; }; /** A number as captured: grouped, never rounded, with a real minus sign. */ declare function formatExplanationNumber(value: number): string; /** A captured value as plain text. Never formatted or rounded here. */ declare function formatExplanationValue(value: CalculationExplanationValue | undefined): string; /** * A captured value the way its property shows values: grouped numbers, the * application currency, `%`, the configured date format, yes/no. An untyped * value (a function result) that is a date reads as one. */ declare function formatTypedValue(value: CalculationExplanationValue | undefined, viewType: string | null | undefined, ctx: ExplanationFormatContext): string; /** A property's current name in the active language. */ declare function displayName(display: CalculationPropertyDisplay | null | undefined, lang: string): string | null; /** `totalLevelWeight` / `is_cancelled` → `Total level weight` / `Is cancelled`. */ declare function humanizeKey(key: string): string; /** * A server-authored text key (`calculation.method.leafAverage`) in the active * language; null for a missing or unknown key. */ declare function serverText(key: string | null | undefined, ctx: ExplanationFormatContext): string | null; /** * What a document's calculation does, in words: its description key, or for * an older capture a generic description of its kind. */ declare function describeDocument(document: CalculationExplanationDocument, ctx: ExplanationFormatContext): string; /** Whether the document's root reads as an equation. */ declare function isEquationDocument(document: CalculationExplanationDocument): boolean; /** * The calculation as readable business wording: inputs by their property * names, operators as symbols, functions as words (`sum of Amount where …`). * `null` when the document is not an equation (a native method, a status * selection, a generated code), or, in `values` mode, when an input is a list * of values the line cannot show (the details list them by record). * * Nodes form a graph: the same input can be reached from several places, and * each place shows it in full. Only a node already on the current path (a * cycle, which a valid document never has) reads as `…`. */ declare function buildExplanationSegments(document: CalculationExplanationDocument, ctx: ExplanationFormatContext, mode?: SegmentMode, startId?: number): ExplanationSegment[] | null; /** Capitalizes the first word, for an equation that starts a line. */ declare function capitalizeSegments(segments: ExplanationSegment[]): ExplanationSegment[]; /** One part of a condition and whether it held. */ interface ExplanationCheckView { segments: ExplanationSegment[]; /** The captured truth; null when it was never evaluated. */ met: boolean | null; /** At least one of these must hold (an `or`). */ anyOf: ExplanationCheckView[] | null; } /** * A condition as a checklist: each part the rule requires on its own line * with whether it held, so a reader sees why a rule matched or which part * failed. Every truth is the captured one; nothing is evaluated here. * * `a and b and c` becomes three parts. `IF(guard, false, rest)` — the usual * "skip when data is missing" form — becomes `Unless guard` plus the parts of * `rest`. An `or` becomes one part whose options are listed. Null when the * document is not an equation. */ declare function buildConditionChecks(document: CalculationExplanationDocument, ctx: ExplanationFormatContext): ExplanationCheckView[] | null; /** A generated code as its parts: `PRJ + - + 2026 + - + 0042`. */ declare function buildCodeSegments(document: CalculationExplanationDocument, ctx: ExplanationFormatContext): ExplanationSegment[]; /** * Captured JSON (native method facts) as labelled fields, lists or tables. * Field names read as business labels; record ids read as a count. */ declare function toExplanationData(value: CalculationExplanationValue | undefined, ctx: ExplanationFormatContext, depth?: number, field?: string): ExplanationData; /** A scalar input the calculation used. */ interface ExplanationValueView { label: string; value: string; } /** List inputs read from the same rows, one row per record. */ interface ExplanationRecordTableView { columns: string[]; rows: { /** The record, for its name; null when the context is unknown. */ ref: CalculationRecordRef | null; cells: string[]; }[]; } /** A nested function and what it gave. */ interface ExplanationStepView { segments: ExplanationSegment[]; result: string; } interface ExplanationFactView { label: string; data: ExplanationData; } interface ExplanationCodeBlockView { type: string; value: string; /** The block's value before its transformations, when it differs. */ raw: string | null; } interface ExplanationStatusRuleView { key: string; name: string; /** Its place in the order rules are checked, from 1. */ position: number; verdict: 'selected' | 'matched' | 'notMatched' | 'checked' | 'failed' | 'notEvaluated'; /** The condition in one line, when it has no checklist. */ segments: ExplanationSegment[] | null; /** The condition as the parts it requires, each with whether it held. */ checks: ExplanationCheckView[] | null; } interface ExplanationContributorView { ref: CalculationRecordRef; type: string | null; progress: string; weight: string; counted: boolean; /** Why it was not counted, or how a missing value was treated. */ reason: string | null; /** A planned item's dates and the working time elapsed of its total. */ planned: { dates: string | null; time: string | null; } | null; } interface ExplanationScheduleView { kind: 'actual' | 'planned' | 'baseline' | 'other'; /** The rollup is the whole formula: its title and result are the summary's. */ standalone: boolean; title: string; /** What this progress means, so actual, planned and baseline read apart. */ meaning: string | null; result: string; /** `Weighted average · Weighted by working days`. */ method: string; /** Contributors actually counted. */ counted: string; notes: string[]; missingBaseline: boolean; weightLabel: string; /** How many items are listed: `12`, or `25 of 265` for a summary. */ listed: string; contributors: ExplanationContributorView[]; /** A large rollup's totals over every item; only some items are listed. */ summary: ExplanationScheduleSummaryView | null; } interface ExplanationScheduleSummaryView { /** Which items are listed: `The 25 items with the most weight`. */ listedItems: string; /** * `Sum of progress × weight (16,340) ÷ Sum of weights (265)`; the result is * the rollup's. Null when nothing was averaged. */ totals: ExplanationSegment[] | null; /** Items counted differently, only when there are any. */ counts: string[]; /** The items by kind, when there is more than one kind. */ groups: ExplanationScheduleGroupView[]; } interface ExplanationScheduleGroupView { type: string; /** `240 of 240`: counted of all. */ counted: string; /** Null for a simple average, where items carry no weight. */ weight: string | null; /** The percentage points these items add to the result. */ share: string; } interface ExplanationDetailsView { /** What a native method or schedule field does, in words. */ description: string | null; values: ExplanationValueView[]; records: ExplanationRecordTableView[]; steps: ExplanationStepView[]; statusRules: ExplanationStatusRuleView[]; schedule: ExplanationScheduleView[]; codeBlocks: ExplanationCodeBlockView[]; facts: ExplanationFactView[]; } /** Everything the details panel shows, read from the document as is. */ declare function buildExplanationDetails(document: CalculationExplanationDocument, ctx: ExplanationFormatContext, statusNames?: Record): ExplanationDetailsView; /** Whether the details have anything beyond the summary. */ declare function hasExplanationDetails(view: ExplanationDetailsView): boolean; /** Every record the details name, for one batch of name reads. */ declare function detailRecordRefs(view: ExplanationDetailsView): CalculationRecordRef[]; /** * The status a rule selects, by the name its property gives it. A status the * host has no name for reads as its key in words (`no_baseline` → `No * baseline`): a generic label would make every rule read the same. */ declare function statusName(key: string, statusNames: Record): string; /** The rule that chose the status, if one did. */ declare function selectedStatusRule(document: CalculationExplanationDocument): CalculationStatusRuleExplanation | null; /** Status rules in the order they are checked. */ declare function orderedStatusRules(document: CalculationExplanationDocument): CalculationStatusRuleExplanation[]; /** Whether a rollup found no baseline at all, so its 0 is not a baseline. */ declare function isMissingBaseline(detail: ScheduleCalculationExplanation): boolean; /** * A readable equation: `Remaining = Budget − Spent`, or its values * `10,000 SAR − 125,454 SAR = −115,454 SAR`. It reads in the page's direction: * functions read as words (`sum of Amount where …`), and in Arabic those words * run right to left. Each term and value is isolated and kept whole, so a name * or an amount never breaks across lines or reorders with its neighbours. * Every piece is interpolated as text. */ declare class CalculationExplanationEquation { readonly segments: _angular_core.InputSignal; /** Shown after the equation, behind `resultOperator`. */ readonly result: _angular_core.InputSignal; readonly resultOperator: _angular_core.InputSignal; protected readonly pieces: _angular_core.Signal<{ segment: ExplanationSegment; space: boolean; }[]>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare const MARKS: Record<'met' | 'notMet' | 'notChecked', { text: string; class: string; }>; /** * A condition as a checklist: each part a rule requires on its own line, * marked met, not met, or not checked (a part evaluation never reached). * An `or` lists its options under "At least one of". */ declare class CalculationExplanationChecks { readonly checks: _angular_core.InputSignal; protected readonly prefix = "components.entitiesPreview.calculationExplanation"; protected readonly marks: Record<"met" | "notMet" | "notChecked", { text: string; class: string; }>; protected markOf(met: boolean | null): keyof typeof MARKS; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * The detailed part of an explanation, shown in its side panel below the * summary. Each part folds, so a long status or schedule reads as a short * list of titles first: records behind list inputs (by name), intermediate * results, status rules (one row each, opening to their checklist), schedule * rollups with their items (a large one in totals, with only its * highest-weight items listed), generated-code parts * and native facts. Everything is the backend's captured data in business * wording; nothing is recalculated here. */ declare class CalculationExplanationDetails { readonly details: _angular_core.InputSignal; /** Record titles by `calculationRecordKey`; `null` while they are read. */ readonly recordNames: _angular_core.InputSignal | null>; /** Generic labels for records without a readable title, by position. */ readonly fallbackLabel: _angular_core.InputSignal<(position: number) => string>; protected readonly prefix = "components.entitiesPreview.calculationExplanation"; protected readonly scheduleKeys = "components.entitiesPreview.calculationExplanation.schedule"; protected readonly openRows = 10; protected readonly verdictClass: Record; /** A record by its title; never by its id. */ protected nameOf(ref: CalculationRecordRef | null, index: number): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * An explanation the backend returned (`available`, or `summarized` for a * large schedule rollup), as the UI keeps it. */ interface AvailableCalculationExplanation { basis: CalculationExplanationBasis; document: CalculationExplanationDocument; definitionChanged: boolean; /** The value on screen was older than the saved one and was re-read. */ refreshed: boolean; viewType: string | undefined; } /** How the calculation reads in short, for the tooltip and the panel. */ interface ExplanationSummaryView { /** `Remaining = Budget − Spent`: the property, then the formula's shape. */ labels: ExplanationSegment[] | null; /** * `10,000 SAR − 125,454 SAR`: the captured values in that shape. Null when * an input is a list of values; the panel lists them by record. */ values: ExplanationSegment[] | null; /** The calculation in words, when it is not a formula. */ description: string | null; /** The status rule that set a status, by its place in the order. */ status: { position: number; total: number; condition: ExplanationSegment[] | null; /** The condition as the parts it required, each with whether it held. */ checks: ExplanationCheckView[] | null; } | null; noRuleMatched: boolean; /** Records a list input read, when the values line can't show them. */ recordCount: number | null; } interface CalculationExplanationView { basis: CalculationExplanationBasis; calculatedAt: string; result: string; summary: ExplanationSummaryView; definitionChanged: boolean; refreshed: boolean; /** A current calculation that differs from the value on the page. */ differs: { page: string; current: string; } | null; /** A baseline rollup found no baseline: its 0 is not an approved 0%. */ missingBaseline: boolean; /** * A summary of a large rollup: totals over every item, only some listed. * `items` is how many items it covers, when the rollup says. */ summarized: { items: number | null; } | null; details: ExplanationDetailsView; hasDetails: boolean; } /** Everything both the tooltip and the details panel show. */ declare function buildCalculationExplanationView(explanation: AvailableCalculationExplanation, target: EntityCalculationExplanationTarget, ctx: ExplanationFormatContext, statusNames: Record): CalculationExplanationView; /** * Whether the saved value is the one on screen. Both are the persisted string, * but a number may be written either way (`40` and `40.0`), so numbers compare * as numbers. */ declare function isSameSavedValue(saved: string | null | undefined, displayed: string | undefined): boolean; /** * The short form of an explanation: the result with its business reason * (`Remaining = Budget − Spent`, then `10,000 SAR − 125,454 SAR = * −115,454 SAR`), and the notices that change how to read it. Shown in the * tooltip and at the top of the details panel. */ declare class CalculationExplanationSummary { readonly view: _angular_core.InputSignal; /** * Whether to say a summarized calculation is a summary. The details panel * does, above the totals and the few items it lists; the tooltip does not. */ readonly summaryNotice: _angular_core.InputSignal; protected readonly prefix = "components.entitiesPreview.calculationExplanation"; protected readonly empty: ExplanationSegment[]; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * The full explanation of a calculated value, in a wide side panel opened from * its tooltip: the result and reason, then the values, contributing records by * name, status rules, schedule rollups and their calendar. * * Created through `ModalService`, so it is built with the root injector and * its inputs arrive through `inputValues`: it takes the explanation the * tooltip already read and only reads the names of the records it shows. */ declare class CalculationExplanationPanel implements OnInit { readonly target: _angular_core.InputSignal; readonly explanation: _angular_core.InputSignal; private readonly names; private readonly transloco; private readonly destroyRef; private readonly explanationContext; protected readonly prefix = "components.entitiesPreview.calculationExplanation"; /** Record titles, `null` while they are being read. */ protected readonly recordNames: _angular_core.WritableSignal | null>; protected readonly view: _angular_core.Signal<_masterteam_components_entities.CalculationExplanationView>; protected readonly fallbackLabel: (position: number) => string; ngOnInit(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type ExplanationState = { kind: 'loading'; } | { kind: 'failed'; } | { kind: 'unavailable'; messageKey: string; } | ({ kind: 'available'; } & AvailableCalculationExplanation); /** * How a calculated value was calculated, in short: the result with its * business reason (`Remaining = Budget − Spent`, then the values), when it was * calculated, and a way into the full details panel. Fetched each time it * opens; reading it never recalculates anything, and nothing here is * recalculated either. */ declare class EntityCalculationExplanation implements OnInit { private readonly api; private readonly modal; private readonly refresher; readonly target: _angular_core.InputSignal; /** The details panel opened; the host closes the tooltip under it. */ readonly detailsOpened: _angular_core.OutputEmitterRef; private readonly explanationContext; protected readonly prefix = "components.entitiesPreview.calculationExplanation"; protected readonly state: _angular_core.WritableSignal; protected readonly available: _angular_core.Signal<({ kind: "available"; } & AvailableCalculationExplanation) | null>; protected readonly unavailableKey: _angular_core.Signal; protected readonly view: _angular_core.Signal<_masterteam_components_entities.CalculationExplanationView | null>; private request?; constructor(); ngOnInit(): void; protected openDetails(): void; private load; private apply; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Says how a calculated number just moved: the signed difference, with the * exact values in its tooltip. */ declare class EntityCalculationChangeChip { private readonly activeLang; readonly change: _angular_core.InputSignal; protected readonly delta: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Anything that can supply a percentage colour: an ordered rule set plus the * fallback used when no rule matches. */ interface PercentageColorSource { colorRules?: PercentageColorRule[] | null; defaultColor?: string | null; } /** * Whether `value` falls inside a rule's band. Both bounds are inclusive, an * absent bound is open-ended, and a rule carrying neither bound is malformed — * it never matches rather than swallowing every value. */ declare function matchesPercentageColorRule(value: number, rule?: PercentageColorRule | null): boolean; /** * The colour for a percentage value: rules in their configured order, first * match wins, `defaultColor` when nothing matches. * * The backend owns this evaluation and ships the winner as `color` on * render/value/fetch responses, so callers must prefer that resolved colour. * This exists for the surfaces that hold a raw rule set and no resolved colour * — the property-form preview, and catalog reads that never went through a * value response. */ declare function resolvePercentageColor(value: unknown, source?: PercentageColorSource | null): string | null; /** * A section is persisted/transported as an ordinary display item whose * `propertyKey` carries this sentinel prefix instead of a real property key * (mirrors the LeafDetails synthetic-key convention). Both the customization * builder and the runtime renderer recognize it, so the constant lives here in * the shared entities layer rather than in either consumer. */ declare const SECTION_KEY_PREFIX = "__section__::"; /** True when a display item's key denotes a section marker. */ declare function isSectionKey(key?: string | null): boolean; /** Mints a unique section marker key. */ declare function buildSectionKey(): string; /** * Resolves a localized label (`{ en, ar }`) for the given language, falling * back across locales. Returns '' when nothing is set. */ declare function resolveLocalizedLabel(label: EntitySectionLabel | null | undefined, lang?: string): string; /** * A run of entities that belong to the same section. `section` is the marker * entity (`viewType: 'Section'`) whose title heads the group, or `null` for the * leading run of entities that appear before the first marker (rendered bare, * with no box — so a card with no markers looks exactly like it did before * sections existed). */ interface EntitySectionGroup { section: EntityData | null; entities: EntityData[]; } /** True when the entity is a `Section` layout marker rather than a value. */ declare function isEntitySection(entity: EntityData | null | undefined): entity is EntityData; /** * Splits a flat, order-sorted entity list into section groups. Membership is * purely positional: each entity belongs to whichever `Section` marker precedes * it. Pass the output of `buildDisplayEntities` (already sorted by `order`). * * Zero markers → a single `{ section: null }` group holding everything, so the * bare-grid rendering is unchanged. Empty leading/trailing runs are dropped. */ declare function groupEntitiesIntoSections(entities: EntityData[]): EntitySectionGroup[]; /** * Resolves a section marker's display label for the given language, falling * back across locales and finally to the entity's `name`. */ declare function getEntitySectionTitle(section: EntityData | null | undefined, lang?: string): string; /** * View types that can be rendered as a card header. * * Text only, deliberately: the header is one centred line naming the record, * and no other view type reads as that — a date, a status chip or a progress * bar stretched across the top of a card is decoration, not a title. */ declare const ENTITY_HEADER_VIEW_TYPES: ReadonlySet; /** True when a property of this view type may be set as the card header. */ declare function canEntityBeHeader(viewType: string | null | undefined): boolean; /** * The entity's header settings, or `null` when it renders as an ordinary cell. * A `header` saved on a view type that cannot be one is ignored rather than * honoured, so the renderers and the builder agree on what is a header. */ declare function resolveEntityHeader(entity: EntityData | null | undefined): EntityHeaderConfig | null; /** True when the entity renders as the card header. */ declare function isEntityHeader(entity: EntityData | null | undefined): boolean; /** * Moves the first header entity to the front of an order-sorted list. * * The header is drawn above the card whatever its saved `order`, so it is * pinned here — in the one ordering every renderer and the builder share — * rather than in each of them. That keeps the builder's drag indexes, its * section-insert index and the runtime card all agreeing on the same list. * * Only the first is moved: a second entity flagged as a header (the drawer * allows one per area, but a configuration can be written elsewhere) stays an * ordinary cell where it is. */ declare function pinEntityHeaderFirst(entities: EntityData[]): EntityData[]; /** * The colours a header with none picked is painted in, as `#rrggbb` — the * values `entity-header.css` produces: the theme's primary as the top border * and a 10% primary tint over white as the background. For showing an author * the defaults (the customization drawer's colour fields), not for saving * them: a stored hex would stop following the tenant's primary colour. * * `null` when the primary colour cannot be resolved in this document. */ declare function readEntityHeaderDefaults(doc: Document): Required | null; /** * A Text entity configured as the card header (`configuration.header`): a * full-width band with a coloured top border and the value centred, no label. * * The band covers its host's padding so it sits flush against the card's top * and side edges. A padded host declares how much padding there is through * three custom properties — see `entity-header.css`. Without them the band * stays inside the content box with ordinary rounded corners. */ declare class EntityHeader { readonly data: _angular_core.InputSignal; private readonly header; /** `null` leaves the stylesheet's primary tint in place. */ readonly backgroundColor: _angular_core.Signal; /** `null` leaves the stylesheet's primary border in place. */ readonly borderColor: _angular_core.Signal; /** * A chosen background can be any colour at all, so the ink is picked to read * on it. The default tint is translucent over the card, so it keeps the * theme's own text colour — which is what flips correctly in dark mode. */ readonly textColor: _angular_core.Signal; readonly displayValue: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EntityPreview { private readonly transloco; readonly data: _angular_core.InputSignal; readonly attachmentShape: _angular_core.InputSignal<"default" | "compact">; private readonly activeLang; /** * The admin-authored note for the active language, or `''` when the property * has none. Resolved here rather than in each `entity-*` component because * this is the one wrapper every view type and every call site passes through * — the card grid, the customization builder preview, and the standalone * `mt-entity-preview` usages in the app. */ readonly infoText: _angular_core.Signal; readonly comparisonKind: _angular_core.Signal<"Value" | "EntityList" | null>; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Owns the view types that render their own nested properties *through* * `EntityValuePreview`. Routing them from inside that component instead would * make the two files import each other, so they branch here and everything * else is delegated. */ declare class EntityPreviewBody { readonly data: _angular_core.InputSignal; readonly attachmentShape: _angular_core.InputSignal<"default" | "compact">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ComparisonValue { readonly data: _angular_core.InputSignal; readonly comparison: _angular_core.Signal; readonly oldEntity: _angular_core.Signal; readonly newEntity: _angular_core.Signal; private buildSide; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface OperationBadge { label: string; classes: string; } declare class ComparisonEntityList { private readonly transloco; readonly data: _angular_core.InputSignal; readonly comparison: _angular_core.Signal; readonly rows: _angular_core.Signal; readonly targetModuleKey: _angular_core.Signal; readonly label: _angular_core.Signal; badgeFor(op: EntityComparisonOperation): OperationBadge; displayField(value: unknown, display?: string | null): string; rowId(_i: number, row: EntityListComparisonRow): number | string; oldField(row: EntityListComparisonRow, propertyKey: string): { value: unknown; display?: string | null; } | undefined; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface EntityClickEvent { entity: EntityData; key: string; source: MouseEvent; } /** * One entity's fully-resolved render inputs. * * Precomputing these is what keeps large grids cheap. The template used to call * `isClickable` / `isActive` / `getColSpan` roughly eight times per entity on * *every* change detection pass; in a client-list card grid (60 cards of ~50 * entities) that was tens of thousands of calls per tick. A slot is now rebuilt * only when the entity list, the clickable/active key sets, or the tooltip * strings actually change. */ interface EntitySlot { entity: EntityData; trackKey: string; containerClass: string; colSpan: string; /** `span N` for a multi-row entity; `null` keeps the default single row. */ gridRow: string | null; clickable: boolean; rowClickIgnore: 'true' | null; title: string | null; } /** A section box (or the leading bare run) with its slots already resolved. */ interface EntitySlotGroup { trackKey: string; boxed: boolean; title: string; slots: EntitySlot[]; } declare class EntitiesPreview { private readonly transloco; /** Array of entity data to display */ readonly entities: _angular_core.InputSignal; readonly attachmentShape: _angular_core.InputSignal<"default" | "compact">; /** * Soft "stack every field full-width when the host is narrower than the * 24-column grid reads well" behavior (the ≤400px container-query fallback, * default on). Set to `false` in wide-enough card layouts — e.g. client-list * cards (~350px) — so the per-entity `size` configuration is honored instead * of forcing every item to full width. A hard ≤280px stack always applies * regardless, so the 24-column gap floor can never overflow the host (#1081). */ readonly stackOnNarrow: _angular_core.InputSignal; /** * Set of entity keys that should appear interactive (cursor pointer, * clicks emit). Pass `new Set([...])` from a computed signal in the host * for reactive enabling — when the host's set changes, Angular re-renders * via its normal change detection, no manual subscriptions required. * * Pass a *stable* reference: a host method that mints a fresh `Set` on every * call re-writes this input on every change detection pass and defeats the * slot memoization below. */ readonly clickableKeys: _angular_core.InputSignal>; /** * Set of entity keys that should render with the "active" treatment * (e.g. currently the filter source). Same reactive pattern — and the same * stable-reference requirement — as `clickableKeys`. */ readonly activeKeys: _angular_core.InputSignal>; /** Tooltip text shown on hover when an entity is clickable but not active. */ readonly clickableTooltip: _angular_core.InputSignal; /** Tooltip text shown on hover when an entity is the current active filter. */ readonly activeTooltip: _angular_core.InputSignal; /** * Emits when an individual entity slot is clicked. Only fires when the * entity's key is present in `clickableKeys`. */ readonly entityClick: _angular_core.OutputEmitterRef; /** * The active language as a signal. Section headings are resolved per-language * in a `computed`, so under `OnPush` a plain `getActiveLang()` read would * freeze them at whatever language was active on first render. */ private readonly activeLang; /** Entities expanded and sorted by order */ readonly displayEntities: _angular_core.Signal; /** * The entity drawn as the card header, or `null`. `buildDisplayEntities` * pins it first, so only the head of the list needs checking. */ readonly header: _angular_core.Signal; /** * The display entities, minus the header, split into section groups. With * no `Section` markers this is a single `{ section: null }` group, so the * bare grid renders exactly as before. */ readonly sectionGroups: _angular_core.Signal<_masterteam_components_entities.EntitySectionGroup[]>; /** * The render model the template iterates. Split from `sectionGroups` on * purpose: grouping only re-runs when the entities themselves change, while * this cheap mapping re-runs when the key sets or tooltips change. */ protected readonly slotGroups: _angular_core.Signal; protected onSlotClick(source: MouseEvent, slot: EntitySlot): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Base class that encapsulates all entity resize-via-drag logic. * * Extend this directive in any component that needs column-resize behaviour * on a 24-column CSS grid. The subclass must: * - Provide a `model.required()` (or equivalent) for the * entity list so `updateEntitySize()` can be called after resize. * - Contain a `.grid` element (or override `getGridElement()`). * * Resize flow: * 1. `onResizeStart(event, entity)` — called from a mousedown on the handle * 2. mousemove → snaps to nearest column, updates `resizePreviewSize` * 3. mouseup → emits `entityResized` with previous & new size */ declare abstract class EntitiesResizeBase { protected readonly elRef: ElementRef; protected readonly zone: NgZone; protected readonly doc: Document; /** Emits when an entity is resized via the drag handle */ readonly entityResized: _angular_core.OutputEmitterRef; /** The entity currently being resized (null when idle) */ readonly resizingEntity: _angular_core.WritableSignal; /** Live preview size while dragging */ readonly resizePreviewSize: _angular_core.WritableSignal; /** Bound listeners kept for cleanup */ private _onMouseMove; private _onMouseUp; /** * Returns the grid element used to compute column widths. * Override if the grid selector differs. */ protected getGridElement(): HTMLElement | null; /** * Returns the grid-column span string for a given entity. * While resizing the active entity, returns the preview size. */ getResizeColSpan(entity: EntityData): string; /** Starts a resize operation from the right-edge handle */ onResizeStart(event: MouseEvent, entity: EntityData): void; /** * Called when a resize operation completes with a changed size. * Subclasses should update the entity list and emit events here. */ protected abstract onResizeComplete(entity: EntityData, previousSize: EntitySize, newSize: EntitySize): void; /** Removes global mouse listeners */ private _cleanupListeners; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class EntitiesManage extends EntitiesResizeBase { /** Array of entity data – supports two-way binding to keep order in sync */ readonly entities: _angular_core.ModelSignal; /** Emits the reordered entities array after each drag-drop */ readonly entitiesReordered: _angular_core.OutputEmitterRef; /** Emits when an entity cell is clicked (for opening edit drawer) */ readonly entityClicked: _angular_core.OutputEmitterRef; /** * Emits when an item dragged from a *different* connected list (e.g. a sidebar * "add section" tool) is dropped onto this grid. `index` is the target slot; * `data` is the dropped `cdkDragData`. The host decides what to insert. */ readonly externalItemDropped: _angular_core.OutputEmitterRef<{ index: number; data: unknown; }>; /** Entities expanded and sorted by their configured order */ readonly displayEntities: _angular_core.Signal; /** * The card header, or `null`. `buildDisplayEntities` pins it first, which is * also where it renders — so it stays in the drop list's data and every drag * index the host receives still lines up with the host's own entity list. */ readonly header: _angular_core.Signal; /** * Keeps every drop below the header. The header is drawn above the card * whatever its order, so an item dropped in front of it would land somewhere * other than where the user let go of it. */ readonly sortPredicate: (index: number) => boolean; /** Returns the grid-column span for a given entity size (1-24) */ getColSpan(entity: EntityData): string; /** Returns the grid-row span (`null` = single row) for a given entity */ getRowSpan(entity: EntityData): string | null; /** True when the entity is a full-width `Section` layout marker. */ isSection(entity: EntityData): boolean; /** True when the entity is the pinned card header. */ isHeader(entity: EntityData): boolean; /** Handle drag-drop reorder */ onDrop(event: CdkDragDrop): void; protected onResizeComplete(entity: EntityData, previousSize: EntitySize, newSize: EntitySize): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Shrinks an atomic value a little rather than letting it truncate. * * A date and an amount are single indivisible facts: `2026/08/16` cut to * `2026/08…` has lost the day, and `100,000 SAR` cut to `100,000 …` has lost * the currency — which is the one part a reader cannot infer. Prose survives an * ellipsis; these do not, so they get one lever before it. * * Why measure instead of thresholding. The first pass at this capped currency * by magnitude — compact anything above 100,000 — with the threshold read off * one measured card slot. But slot width is a property of the card layout, not * of the number: the three-across boxes on an Explore card are far narrower * than the slot that was measured, so `100,000 SAR` and `50,000 SAR` sat under * the threshold and truncated anyway. No constant can know the width it has. * This asks the element. * * The element keeps its `truncate`, so anything still too long at the floor * ellipsizes exactly as before — with the tooltip callers already attach * carrying the full value. Shrinking is a nudge, never the whole answer. */ declare class FitText { /** Set false to leave a particular instance alone. */ readonly mtFitText: _angular_core.InputSignalWithTransform; private readonly host; private readonly destroyRef; private basePx; private frame; private resizeObserver?; private mutationObserver?; constructor(); private schedule; private fit; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare function sharedActiveLang(transloco: TranslocoService): Signal; export { CALCULATION_CHANGE_CHIP_MS, CALCULATION_EXPLANATION_KEYS, CONNECTION_KEY_SEPARATOR, CURRENCY_COMPACT_THRESHOLD, CalculatedValueHistory, CalculationExplanationApi, CalculationExplanationChecks, CalculationExplanationDetails, CalculationExplanationEquation, CalculationExplanationPanel, CalculationExplanationSummary, CalculationRecordNames, ComparisonEntityList, ComparisonValue, DEFAULT_PERFORMANCE_SCORE_CHART_SIZE, DEFAULT_PHASE_GATE_COLOR, ENTITY_EMPTY_VALUE_PLACEHOLDER, ENTITY_HEADER_VIEW_TYPES, ENTITY_LIST_TABLE_COMPONENT, ENTITY_ROW_SPANS, EntitiesManage, EntitiesPreview, EntitiesResizeBase, EntityAttachment, EntityCalculatedGlyph, EntityCalculatedIndicator, EntityCalculationChangeChip, EntityCalculationExplanation, EntityCalculationRefresher, EntityCheckbox, EntityColor, EntityConnection, EntityCurrency, EntityDate, EntityField, EntityHeader, EntityIcon, EntityLeafDetails, EntityListDrawer, EntityListPreview, EntityLocation, EntityLongText, EntityLookup, EntityLookupModuleCheckList, EntityPercentage, EntityPerformanceScore, EntityPhaseGate, EntityPreview, EntityPreviewBody, EntityRuntimeContextStore, EntityScheduleItem, EntityStatus, EntityText, EntityUser, FitText, LEAF_DETAILS_KEY_SEPARATOR, LEAF_PHASES_KEY_SEPARATOR, MT_CALCULATION_CURRENCY, MT_CALCULATION_STATUS_NAMES, PERFORMANCE_SCORE_CHART_SIZES, SECTION_KEY_PREFIX, buildCalculationExplanationView, buildCodeSegments, buildConditionChecks, buildConnectionKey, buildDisplayEntities, buildEntityListRows, buildExplanationDetails, buildExplanationSegments, buildSectionKey, calculationRecordKey, canEntityBeHeader, capitalizeSegments, compactCurrencyDisplay, currencyUnitOf, describeCalculationChange, describeDocument, detailRecordRefs, displayName, displayOrPlaceholder, expandConnectionEntity, expandLeafDetailsEntity, extractDisplayText, formatCalculationDelta, formatExplanationNumber, formatExplanationValue, formatTypedValue, getEntitySectionTitle, getPerformanceScoreBands, groupEntitiesIntoSections, hasExplanationDetails, humanizeEntityListKey, humanizeKey, isCalculatedProperty, isConnectionSyntheticKey, isEntityAlignEnd, isEntityHeader, isEntityLabelHidden, isEntityListLocalDocument, isEntityListSelectionDocument, isEntitySection, isEquationDocument, isLeafDetailsCatalogConfiguration, isLeafDetailsCollectionValue, isLeafDetailsRuntimeValue, isLeafDetailsSyntheticKey, isLeafDetailsValue, isLeafPhasesSyntheticKey, isLeafSyntheticKey, isMissingBaseline, isSameSavedValue, isSectionKey, isValueMissing, localCellsByFieldId, matchesPercentageColorRule, mergeStakeholderNameColumns, mergeStakeholderNameEntities, mergeStakeholderNameRows, normalizeConnectionSourceLevels, normalizeNumerals, orderedStatusRules, parseCurrencyAmount, parsePerformanceScore, pinEntityHeaderFirst, readEntityHeaderDefaults, readEntityValueColor, resolveConnectionLevelName, resolveEntityGridRow, resolveEntityHeader, resolveEntityInfo, resolveEntityLabelPosition, resolveLocalFieldConfiguration, resolveLocalFieldLabel, resolveLocalFieldViewType, resolveLocalizedLabel, resolvePercentageColor, resolvePerformanceScoreStatus, selectedStatusRule, serializeEntityRawValue, serverText, sharedActiveLang, sortLocalRows, splitConnectionKey, splitLeafKey, statusName, summarizeEntityListRows, toCalculationContextKey, toCalculationExplanationTarget, toExplanationData, toFetchContextKey, visibleLocalSchemaFields }; export type { AvailableCalculationExplanation, CalculatedPropertyMeta, CalculationExplanationBasis, CalculationExplanationDocument, CalculationExplanationNode, CalculationExplanationNodeKind, CalculationExplanationProvider, CalculationExplanationResponse, CalculationExplanationSourceRecords, CalculationExplanationStatus, CalculationExplanationValue, CalculationExplanationView, CalculationPropertyDisplay, CalculationRecordRef, CalculationStatusNames, CalculationStatusRuleExplanation, ComparisonValueSide, ConnectionCatalogConfiguration, ConnectionLevelSavedConfig, ConnectionSourceLevelConfig, EntityAttachmentItemValue, EntityAttachmentValue, EntityBaseConfig, EntityCalculationChange, EntityCalculationExplanationTarget, EntityCalculationSource, EntityCalculationStatus, EntityClickEvent, EntityComparisonField, EntityComparisonOperation, EntityConfiguration, EntityConnectionConfig, EntityConnectionSourceValue, EntityConnectionValue, EntityData, EntityHeaderConfig, EntityLabelPosition, EntityLeafDetailsConfig, EntityListComparison, EntityListComparisonRow, EntityListEntityValue, EntityListInlineFieldMeta, EntityListLocalCell, EntityListLocalDocument, EntityListLocalFieldDefinition, EntityListLocalFieldWidth, EntityListLocalRow, EntityListLocalSchema, EntityListLocalSchemaField, EntityListRenderedRow, EntityListRowValue, EntityListSelectionDocument, EntityListSelectionRecord, EntityListSelectionRecordValue, EntityListTableHost, EntityListTranslatable, EntityListValueItem, EntityLocationValue, EntityLookupCheckListItem, EntityLookupCheckListPropValue, EntityLookupCheckListValue, EntityLookupValue, EntityMultiLookupValue, EntityMultiUserValue, EntityNestedPropertyMeta, EntityPercentageConfig, EntityPerformanceScoreChartSize, EntityPerformanceScoreConfig, EntityPerformanceScoreStatus, EntityPerformanceScoreValue, EntityPhaseGateValue, EntityPropertyConfiguration, EntityResizeEvent, EntityRowSpan, EntityRuntimeContext, EntityScheduleItemValue, EntitySectionConfig, EntitySectionGroup, EntitySectionLabel, EntitySize, EntityStatusValue, EntityTranslatableTextValue, EntityUserConfig, EntityUserValue, EntityViewType, ExplanationCheckView, ExplanationCodeBlockView, ExplanationContributorView, ExplanationData, ExplanationDetailsView, ExplanationFactView, ExplanationFormatContext, ExplanationRecordTableView, ExplanationScheduleGroupView, ExplanationScheduleSummaryView, ExplanationScheduleView, ExplanationSegment, ExplanationStatusRuleView, ExplanationStepView, ExplanationSummaryView, ExplanationValueView, LeafDetailsBadgeKind, LeafDetailsCatalogConfiguration, LeafDetailsCatalogLevelValue, LeafDetailsCatalogPhaseValue, LeafDetailsCatalogStatusValue, LeafDetailsEntityCollectionValue, LeafDetailsEntityValue, LeafDetailsPhaseSummary, LeafDetailsRuntimeChildSchema, LeafDetailsRuntimePhaseCount, LeafDetailsRuntimePhaseDetails, LeafDetailsRuntimeStatusCount, LeafDetailsRuntimeStatusDetails, LeafDetailsRuntimeValue, LeafDetailsStatusSummary, LeafLevelSavedConfig, LeafPhaseSavedConfig, PercentageColorMode, PercentageColorPropertyRef, PercentageColorRule, PercentageColorSource, PlannedProgressExplanation, PropertyValueComparison, ScheduleCalculationContributor, ScheduleCalculationExplanation, ScheduleCalculationSummary, ScheduleCalculationSummaryGroup, SegmentMode, ValueComparison };