Type aliases

Visual variant for the action button - maps to a CSS class.

Severity level for the alert - determines visual style, icon, and ARIA role.

Visibility phase for enter/exit CSS animations.

Primary edge of the popover panel that faces the trigger after browser- driven shift / flip recovery. Driven by CngxPopover.resolvedEdge; consumers projecting a cngxPopoverArrow template receive this value in the slot context so they can rotate or position their glyph accordingly.

Permitted values for aria-haspopup on a popover trigger. Mirrors the W3C-spec union for popup-container roles plus the bare 'true' compatibility value. Composers (such as CngxPopoverPanel) write the popover's haspopup signal to hint the trigger toward the right value without forcing the consumer to repeat it.

Native popover attribute mode.

ARIA roles applicable to a CngxPopoverPanel host element.

Anchor-relative placement of a popover.

CSS <try-tactic> keywords for the position-try-fallbacks property (CSS Anchor Positioning Level 1). Each entry is written verbatim into the host's position-try-fallbacks style; entries are not resolved through any cngx mapping table.

The union enumerates both orderings of two-keyword composites (flip-block flip-inline vs flip-inline flip-block) so consumers can match the canonical ordering Chrome resolves to when it normalises the cascaded value. Three-keyword composites are commutative enough that one form suffices.

Mirrors the precedent in projects/forms/select/shared/select-base.css which already ships position-try-fallbacks: flip-block, flip-inline, flip-block flip-inline; on select panels.

Lifecycle state of a popover element.

Which event sources may open CngxTooltip.

• 'auto' (default) - hover and focus open the tooltip with the configured tooltipDelay / closeDelay. show() and hide() remain available for programmatic overrides.
• 'manual' - hover and focus are inert. Only show() / hide() open or close the tooltip. Escape still dismisses an open tooltip for keyboard accessibility.

Action function that returns a Promise or Observable.

Discriminated status of an async operation lifecycle.

Possible view states for async content rendering.

Lifecycle state of the shared AudioContext, surfaced for debug panels and headless e2e. Mute is a separate muted signal — this tracks the context, not the play gate.

Signature of the engine factory — the shape a telemetry/audit override matches.

Reads the bar height (data-space Y) of a data row at index i.

Discriminated-union shape returned by withAccordionLabels / withDefaultHeadingLevel. The reducer in provideAccordionConfig / provideAccordionConfigAt matches on kind and writes payload onto the corresponding config key. Mirrors CngxBreadcrumbConfigFeature from @cngx/ui/breadcrumb so the consumer's mental model is one across feature areas.

Per-item semantic severity, reflected onto the [data-severity] host attribute for skins that visualise it (the severity-spine skin maps it to the --cngx-color-danger / -warning / -info tokens). Structural only - it changes no ARIA and no behaviour, and unset items simply carry no severity.

Selectable visual skin for <cngx-accordion-group>.
The skin is a pure thematic concern - every value renders the identical heading / region / marker structure, slots, ARIA, and keyboard behaviour, and only redirects CSS via the [data-skin] host attribute. Typed class-sugar (mirrors CngxTabsSkin), not a behaviour-branching mode flag.

'editorial' mono index + hairlines; 'categorized' bordered surface cards; 'plus-minus' one framed surface with a boxed +/- marker; 'lux' generous whitespace, large type; 'bento' container-query card grid; 'section-bands' inverted full-width header bands; 'timeline' a rail with per-item nodes; 'severity-spine' a full-height priority spine; 'primary-frame' a solid primary border + glow on open.

Focus-trap policy for the action-slot workflow:

• 'dirty' (default) - trap on while actionDirty() is true.
• 'always' - trap on whenever the panel is open.
• 'never' - shell never engages the trap; consumer owns focus.

Slot position inside the panel frame. Default 'bottom'.

Factory signature for CNGX_ACTION_HOST_BRIDGE_FACTORY.

Factory signature for CNGX_ARRAY_COMMIT_HANDLER_FACTORY.

Display bucket a reflector collapses an CngxAsyncState into. The loading / refreshing busy variants fold into pending for the visible status, while isBusy carries the full busy set for ARIA.

Store members contributed by withCngxAsyncState(key).

• <key>State - the read-only CngxAsyncState<T> view, for [state] bindings and the CngxToastOn / CngxAlertOn / CngxBannerOn bridges.
• <key>Sink - the writable ManualAsyncState<T> that tapAsyncState drives.

A [cngxAudio] DOM event name.

The public audio handle — what injectCngxAudio returns.

An alias for CngxAudioEngine rather than a second interface: the two contracts were member-for-member identical, so a separate declaration was duplication, not indirection. The name is kept because it reads better at call sites (const audio: CngxAudioHandle = injectCngxAudio()), and because the engine contract is the one an override implements.

Signature of the tone-generator factory — the shape an override must match.

Axis position. Top/bottom are X-axes; left/right are Y-axes. The parent <cngx-chart> collects content-child axes and routes their inputs to its xScale / yScale signals based on this discriminator.

Axis scale type. The chart's scale-builder picks the matching create*Scale factory at the boundary; the axis itself stays scale-implementation-agnostic.

Color palette options for the badge.

Positioning anchors relative to the host element.

A collapse strategy decides which crumb indices fold into the overflow menu. Pure and synchronous: given the total crumb count and the maxVisible cap it returns the set of indices to hide. Swap it via CNGX_BREADCRUMB_COLLAPSE_STRATEGY to change the rule (width-aware, keep-first-N, mobile parent-only, ...) without forking CngxBreadcrumb.

Discriminated-union shape returned by the breadcrumb config features - withBreadcrumbAriaLabels, withBreadcrumbDataKey, withBreadcrumbIconKey, and withBreadcrumbSkin. The reducer in provideBreadcrumbConfig / provideBreadcrumbConfigAt matches on kind and merges payload into the corresponding config sub-tree (dataKey and iconKey both land under the router sub-tree). Mirrors CngxTagConfigFeature from @cngx/common/display so the consumer's mental model is one across feature areas.

Selectable visual skin for CngxBreadcrumbBar. Every skin keeps the same nav / list / crumb / separator structure with identical ARIA and collapse behaviour, and the [data-skin] host attribute redirects which @scope paint block applies. Pure paint skins (plain, contained, pill, ribbon, editorial, header, metro, toolbar, chips) render identical DOM. The content skins (iconlabel, path, and the content- structural icononly / shell / record) additionally consume the projected *cngxBreadcrumbIcon slot - and record the trailing accessory slot - for per-crumb icon/content markup the consumer supplies; the bar still carries no skin-conditional template branch, so the slot is inert until projected (Pillar 3). 'classic' is the bare default (plain link + slash separator). Mirrors CngxTabsSkin.

Factory signature for CNGX_CHIP_REMOVAL_HANDLER_FACTORY.

Signature of the factory behind CNGX_CHIP_STRIP_ROVING_FACTORY.

Factory signature for producing CngxCommitController instances. Consumers override the DI token CNGX_COMMIT_CONTROLLER_FACTORY with a custom factory to inject retry-with-backoff, offline queues, telemetry, or any other enterprise-specific commit lifecycle - without forking the features that consume it (select family, stepper, future wizards).

Scalar-commit failure announce policy.

• verbose - error text verbatim into the live-region at the supplied severity. CngxSelect uses assertive.
• soft - generic "removed" via the configured announcer format, polite. CngxTypeahead uses this so the free-text flow isn't interrupted.

Factory signature for CNGX_COMMIT_ERROR_ANNOUNCER_FACTORY.

Action runner contract. Receives the controller's success/error routes and returns a cancel handle. The runner is opaque to the controller — it can wrap any async source (Observable, Promise, sync value) and any cancellation primitive.

Variants supply their own runner adapter (e.g. select's runCommitAction invokes a CngxSelectCommitAction<T>; stepper's runner adapts a CngxStepperCommitAction); the controller has no knowledge of the variant-specific action shape.

Signature of the factory behind CNGX_CREATE_COMMIT_HANDLER_FACTORY.

Curve interpolators for line / area path builders. Each function returns the interior path commands that connect a series of points; the caller is responsible for the leading M and any trailing close commands.

Pure TS, no DOM dependency, no Angular dep.

Per-row semantic severity, reflected onto the [data-severity] host attribute for skins that visualise it (the log-stream skin maps it to a coloured left edge via the --cngx-color-danger / -warning / -info tokens). Structural only - it changes no ARIA and no behaviour, and unset rows simply carry no severity.

Re-declared locally as an identical union rather than imported from the accordion entry, so this entry pulls in nothing from a sibling @cngx/ui entry. The duplication is a tracked decision, re-evaluated if a shared severity union lands in @cngx/core.

Selectable visual skin for <cngx-data-grid-accordion>.
The skin is a pure thematic concern - every value renders the identical header / row / region structure, cells, ARIA, and keyboard behaviour, and only redirects CSS via the [data-skin] host attribute. Typed class-sugar (mirrors CngxAccordionSkin), not a behaviour-branching mode flag.

'ledger' zebra rows + sum footer; 'spreadsheet' cell hairlines + row-number gutter; 'log-stream' mono grid with a severity edge; 'master-detail' primary-tinted open row + sub-table detail; 'report' frameless double rules; 'density' compact/standard/spacious token hooks.

The three density rungs the [data-density] scale swap ships (density-tokens.css). comfortable is the library default; compact and spacious re-scale --cngx-space-* for the subtree.

Inline alignment of a data-grid cell within its column track.

Column-sizing intent for a data-grid track, authored on the cngxDgaCells of the CngxDataGridHeader (the single column source). The group derives the shared grid-template-columns from these:

• grow - the flexible column, minmax(0, 1fr); shares the remaining width.
• fit - content-sized, auto; as wide as its content needs.
• sm / md / lg - fixed tracks from the --cngx-dga-col-sm|-md|-lg tokens (mirrors the size vocabulary of CngxTag / CngxIcon / CngxAvatar).

Unset falls back to the derived default: the primary column grows, every other column fits.

Factory signature for CNGX_DIRECTIVE_BY_ID_MAP_FACTORY.

Factory signature for CNGX_DISMISS_HANDLER_FACTORY.

Factory signature for CNGX_DISPLAY_BINDING_FACTORY.

Factory signature for CNGX_DOM_ANCHOR_RETRY_FACTORY - matches createDomAnchorRetry for drop-in overrides.

Outcome reported by an attempt callback. true halts the loop (success); false or null schedules another tick.

A callable that returns a CngxFieldRef - matches the shape of Angular Signal Forms' Field<T>.

// Signal Forms field is already a callable:
const emailField: Field<string> = schema(...);
// Pass directly:
<cngx-form-field [field]="emailField">

A function that maps a validation error to a human-readable message string.

A map of validation error kind strings to their message rendering functions.

const messages: ErrorMessageMap = {
  required: () => 'This field is required.',
  minLength: (e) => `Minimum ${(e as unknown as { minLength: number }).minLength} characters.`,
};

Factory signature carried by CNGX_FILTER_BUILDER_ANNOUNCER_FACTORY.

Valid keys of the default glyph map.

Signature alias for createFilterBuilderState. Allows enterprise consumers to wrap the default factory with telemetry, persistence, undo stacks, or other cross-cutting concerns via CNGX_FILTER_BUILDER_STATE_FACTORY without forking CngxFilterBuilderPresenter. Mirrors the select-family Cngx*ControllerFactory precedents (e.g. createCommitController + CNGX_SELECT_COMMIT_CONTROLLER_FACTORY).

Plain-TS state factory for <cngx-filter-builder>. Wraps a single writable signal as the canonical tree source-of-truth, derives read-only signals (tree, fieldMap, isEmpty), exposes path-keyed mutators, and emits a structural lastMutation event slot the presenter watches to drive announcements. No inject() calls - the factory is testable without TestBed and decompose-safe (DI abstraction).

Two-way binding contract - pass the presenter's model<FilterGroup>() as source. Mutators write through it, so consumer [(value)] bindings emit on every user-initiated change. Uncontrolled callers omit source; the factory creates its own WritableSignal from initial ?? EMPTY_ROOT.

Identity & equality - tree is wrapped with equal: filterTreeEqual so consumer computeds short-circuit on structural equality. Mutators are no-op when the requested write would not change the tree.

Factory signature carried by CNGX_FILTER_BUILDER_TEMPLATE_REGISTRY_FACTORY.

Editor-registry value type. Either one of the three native sentinels, or a consumer-supplied component class implementing CngxFilterEditorComponent (e.g. CngxInput, CngxNumericInput, CngxDatepickerInput, or any structured custom editor).

Native-input sentinel union. When CNGX_FILTER_BUILDER_CONFIG.editors maps a key to one of these strings, the filter-builder component (Phase 5) renders the corresponding bare HTML input inline instead of mounting a custom editor component - keeps the bundle lean for the three builtin scalar types.

Strategy result. Pure policy - variant dispatches.

Outcome dispatched by a CngxHierarchicalNavStrategy step. CngxHierarchicalNav interprets the action: fires the matching output, calls event.preventDefault() for anything non-noop, and (for move actions) relies on the strategy having already called ad.highlightByValue on the context.

A single configuration override produced by a with* feature factory. The reducer in provideIncrementalListConfig matches on kind and shallow-merges payload into the matching sub-tree.

Visual skin. Paint-only - structure, ARIA, and keyboard behaviour are identical across values; each is reflected onto [data-skin].

• plain (default): browser-native list, no chrome.
• divided: hairline separators between rows.
• card: the list sits on an elevated, rounded surface.

Factory signature for CNGX_LOCAL_ITEMS_BUFFER_FACTORY.

Factory signature for createMatStepHandle. The DI token CNGX_MAT_STEP_HANDLE_FACTORY resolves to a function with this exact shape - overrides match it identically.

Sink callback invoked by [cngxMatTabs]'s aggregator-decoration projector when a consumer wires exactly one of *cngxMatTabAggregatorContent (the slot template) or ViewContainerRef (the embedded-view host) — the half-wired-slot misconfiguration. The projector silently falls back to the imperative textContent path when this happens; the sink is the only deliberate signal that the consumer's slot template will not render.

Override via provideMatTabsConfig(withHalfWiredSlotSink(fn)) to wire production telemetry (Sentry breadcrumbs, custom logger, CI fail-fast). The library default is a dev-mode console.warn; the exported CNGX_DEFAULT_HALF_WIRED_SLOT_SINK value lets test doubles compose against a stable reference.

Factory signature for createMatTabHandle. The DI token CNGX_MAT_TAB_HANDLE_FACTORY resolves to a function with this exact shape - overrides match it identically.

Factory shape consumed by CNGX_MENU_ANNOUNCER_FACTORY. The default factory is createMenuAnnouncer; override returns any object that satisfies CngxMenuAnnouncerLike.

Single feature-flag function consumed by provideMenuConfig and provideCngxMenu. Carries a hidden _target discriminator so future config surfaces (e.g. submenu-only or announcer overrides) can compose through the same provideCngxMenu aggregator without breaking the public API of existing with* features.

Factory signature for CNGX_MENU_DISMISS_HANDLER_FACTORY.

Identifier for the dismissal path that fired most recently.

• outside-click - pointerdown outside both the popover and the trigger host.

• scroll - window scroll while the menu is open.

• blur - window blur (system notification, OS-native context menu overlaying the cngx menu).

• pointer-cancel - document pointercancel originating OUTSIDE the popover and host (palm rejection from outside the menu, gesture cancelled by the browser). In-menu palm rejections do not dismiss.

• escape - document keydown matching the Escape key while the popover is visible. Detected by the factory's capture-phase keydown listener so the source is recorded regardless of where DOM focus sits (trigger button, menu container, or elsewhere).

  Intent, not effect. The factory records 'escape' synchronously on the keystroke and does NOT call popover.hide(). Whether the menu actually closes is owned by CngxPopover.closeOnEscape: consumers who set [closeOnEscape]="false" keep their menu open even though lastSource reports 'escape'. The other sources (outside-click, scroll, blur, pointer-cancel) call popover.hide() themselves and so always coincide with an actual close - 'escape' is the one source where intent and effect can diverge.

Union of every feature kind the menu family aggregator accepts. Today that is only CngxMenuConfigFeature (target 'config'); future surfaces (e.g. submenu-only or announcer overrides) will widen this union and provideCngxMenu will dispatch to the matching provide*Config based on each feature's hidden _target discriminator.

Outcome dispatched by a CngxMenuNavStrategy step. Consumers (the menu trigger or a future menubar directive) interpret the action: fire the matching side effect (open/close a popover, hand focus to a parent menu) and event.preventDefault() for anything non-noop.

Factory shape - pass into a custom DI provider to wrap selection in telemetry, server-sync, or audit logging without forking CngxMenuGroup.

Discriminated union describing one direct child of a hierarchy-aware option projection root (e.g. CngxSelectShell).

CngxOption registers as { kind: 'option' }, CngxOptionGroup as { kind: 'group' }. Both providers expose useExisting so consumers can inject(CNGX_OPTION_CONTAINER) and reach the directive instance through the discriminator.

Factory signature for CNGX_ORGANISM_SCROLL_SYNC_FACTORY.

Factory signature for CNGX_OVERFLOW_POPOVER_HIGHLIGHT_FACTORY.

Config accepted by CngxOverlay.open. Partial alias of CDK's OverlayConfig - every field is optional and falls back to the CDK overlay default.

The shape an override must match to swap the announcer derivation.

A single configuration override produced by a with* feature factory. The reducer in provideCngxPaginatorConfig matches on kind and shallow-merges payload into the matching sub-tree - except pageSizeOptions, whose payload replaces the list wholesale.

Density preset. Shifts spacing/hit-target tokens; orthogonal to skin.

Visual skin. Paint-only - structure, ARIA, and keyboard behaviour are identical across values.

The shape an override must match to swap the page-window computation.

The page-window computation cngx-pgn-pages calls per recompute: given the current 0-based page, the total page count, and the per-instance siblingCount / boundaryCount, return the rendered PageWindow.

An override implements a different truncation algorithm while still honouring the consumer's sibling / boundary intent.

Factory signature for CNGX_PANEL_LIFECYCLE_EMITTER_FACTORY.

Factory signature for CNGX_PANEL_RENDERER_FACTORY.

Pure estimator signature: maps a raw password to a PasswordStrengthResult. Swap the default app-wide through CNGX_PASSWORD_STRENGTH_FACTORY (e.g. a zxcvbn-backed estimator) without touching CngxPasswordStrength.

Coarse password-strength label paired with the 0..4 score. The four labels map onto the five scores so a score of 0 and 1 both read as 'weak'.

Factory signature for CNGX_PROJECTED_OPTION_MODEL_FACTORY.

Signature of the factory behind CNGX_REORDER_COMMIT_HANDLER_FACTORY.

Modifier key that arms the keyboard-reorder handler. Plain arrow keys keep their default meaning (focus navigation) - only the configured modifier + arrow produces a move.

Factory signature for CNGX_SCALAR_COMMIT_HANDLER_FACTORY.

Factory signature for CNGX_SEARCH_EFFECTS_FACTORY.

Feature union for provideCngxSelect / provideCngxSelectAt. The hidden _target discriminator routes each feature to its underlying provider (select/action/reorderable).

Selection-indicator slot context. Discriminated on variant - radio has no indeterminate; narrow on variant before reading.

Async write handler invoked on a pick when [commitAction] is bound. Receives the intended value (undefined on clear). Resolves to the committed value - typically the intended value, or a server-normalised variant.

Default error UI when no *cngxSelectCommitError slot is projected.

• 'banner' (default) - top-of-panel banner.
• 'inline' - indicator next to the offending option row.
• 'none' - no built-in UI; bridge via CngxToastOn etc.

Panel UX during an in-flight commit. Consecutive picks supersede.

• 'optimistic' (default) - panel closes, trigger shows intended value, rolls back on error.
• 'pessimistic' - panel stays open, option-row spinner, trigger disabled. Closes on success; stays open on error with inline UI.

Factory signature for CngxCommitController instances scoped to the select family. Override this token (retry-with-backoff, offline queues, telemetry) without touching call sites.

Value-to-option equality. Default Object.is; override via [compareWith].

Async write handler for the action-slot commit() callback. Receives the live searchTerm plus the drafted { label }. Always resolves to a definite T - a successful create yields a materialised value.

Factory signature for SelectionController — the exact shape of createSelectionController, carried as a DI-overridable symbol so consumers can swap the selection engine app-wide (telemetry wrappers, audit logging, server-synced selections, …) without forking any component that depends on it.

First-load async view variant. Per-instance *cngxSelectLoading wins.

Subsequent-load indicator overlaying visible options. Per-instance *cngxSelectRefreshing wins. 'none' suppresses.

Selection-indicator position relative to the option label.

Selection-indicator glyph.

• 'auto' - 'checkbox' for multi/combobox, 'checkmark' for single.
• 'checkbox' - bordered checkbox.
• 'checkmark' - bare checkmark.
• 'radio' - dot-in-circle. Single-select intent; multi panels render it but the exclusive-selection visual is misleading there.

Mixed flat-or-grouped options accepted by [options] in data-driven mode.

Discriminated-union shape returned by the sidenav config features - withSidenavDimensions, withSidenavResponsive, withSidenavShortcut, withSidenavHoverDwell, and withSidenavRouterSync. The reducer in provideSidenavConfig / provideSidenavConfigAt matches on kind and merges payload into the corresponding config sub-tree: dimensions, hover, and routerSync are one-level nested sub-trees, responsive and shortcut are flat top-level scalars. Mirrors CngxBreadcrumbConfigFeature from @cngx/ui/breadcrumb (nested-sub-tree style; the stepper family uses flat scalar keys instead).

Which end of a range slider a CngxSliderThumb drives.

The four coordinated slots of a CngxStat, in reading order.

Async-commit action for stepper transitions. Receives the origin and target indices; resolves true to advance, false to refuse. The Observable | Promise | sync union matches every cngx commit-action signature.

Factory signature for CngxStepperCommitHandler. Override CNGX_STEPPER_COMMIT_HANDLER_FACTORY for retry-with-backoff, telemetry, or offline queues.

Feature signature - each with* builder reduces over the config. Hidden _target: 'config' discriminator routes through the family aggregator provideCngxStepper.

Space-driven density policy for the classic <cngx-stepper> strip. 'auto' degrades the strip on its own container width (full labels -> ellipsis-truncated -> indicators-only with the active label kept); 'comfortable' (default) keeps full labels at every width. Orthogonal to mobileCollapse and groupCollapse; the Material twin ignores this setting.

Focus-driven group-collapse policy for grouped <cngx-stepper> flows. 'expand-active' collapses every non-active cngxStepGroup branch to its header node and expands only the group holding the active step; 'off' (default) keeps every group's children rendered in the strip - the browser-native baseline. Orthogonal to the mobileCollapse axis; the two never edit each other. The Material twin ([cngxMatStepper]) ignores this setting.

What a collapsed cngxStepGroup header shows next to its label under groupCollapse: 'expand-active'. 'progress' (default) shows completed/total steps; 'count' shows the step count; 'status' shows a status dot coloured by the group's rolled-up state; 'off' shows the bare label. Only ever rendered on a collapsed group header.

Header-navigation policy for <cngx-stepper>. 'none' renders the step headers as inert labels - the footer is the sole navigation control. 'visited' (default) keeps the headers as focusable buttons; reachability folds into the linear axis (linear=false is free click-through, linear=true is backward-to-visited only, with linear-unreachable headers marked aria-disabled). There is no discrete 'free' value - 'free' is 'visited' + linear=false.

Mobile auto-collapse target. Under a narrow viewport (max-width: 480px), <cngx-stepper> falls back to one of the compact variants instead of rendering the full strip. Set to 'off' to retain the classic strip on every viewport.

Where the mobile auto-collapse indicator (text caption or dot row) sits relative to the active step's panel content under narrow viewports. 'top' (default) keeps the indicator above the panel; 'bottom' flips it below so the user reads content first and the navigation cue sits at the thumb zone. Ignored when the classic strip is on screen (displayMode === 'classic').

Selectable visual skin for the cngx-standard stepper. The skin is a pure thematic concern - every value renders the same structure, same slots, same ARIA, same keyboard behaviour, and only redirects CSS via the [data-skin] host attribute. The Material twin (<cngx-mat-stepper>) ignores this setting.

Union of every feature kind provideCngxStepper accepts. Today: config (CNGX_STEPPER_CONFIG) and i18n (CNGX_STEPPER_I18N). Future surfaces widen this union and dispatch via the hidden _target discriminator.

Feature shape consumed by provideStepperI18n and provideCngxStepper. Hidden _target: 'i18n' discriminator routes through the family aggregator. Sibling of CngxTabsI18nFeature.

Partial-override shape for withStepperI18nLabels. Behaves as Partial<CngxStepperI18n> for top-level keys, plus a nested partial for CngxStepperStatusLabels so consumers can override one pill label without restating the full status-label bundle.

Status enum for a single step. Driven by the presenter's commit-controller lifecycle plus the optional errorAggregator.

Resolved density rung for the classic <cngx-stepper> strip. 'full' shows every label; 'compact' ellipsis-truncates labels; 'minimal' drops to indicators-only (the active step keeps its label). Orthogonal to the mobileCollapse display-mode union.

Horizontal alignment of the tab cluster along the strip, set via the [tabAlign] Input and reflected onto [data-tab-align]. 'start' (default), 'center', or 'end'. Horizontal only - ignored under orientation="vertical" (tabs fill the column) and when [fitted] stretches them to the full width.

Icon-layout axis for <cngx-tab-group>, orthogonal to both skin and orientation.
Positions the *cngxTabIcon slot relative to the tab label: 'start' (default) places the icon before the label in a row; 'end' places it after the label in a row; 'top' stacks the icon above the label in a column; 'only' hides the label visually while keeping it in the DOM as the accessible name.

Redirected purely via the [data-icon-layout] host attribute.

Feature signature for with* config builders.
The hidden _target discriminator lets provideCngxTabs dispatch config features to provideTabsConfig while i18n features route to provideTabsI18n.

Panel render strategy for <cngx-tab-group>.
The panel <div> (the aria-controls target) always stays in the DOM; only its content is rendered per mode. 'eager' (default) renders every panel's content up front and toggles visibility via [hidden] - today's behaviour, byte-identical. 'lazy' renders a panel's content the first time it is activated and keeps it (keep-alive). 'lazy-destroy' renders only the active panel's content and destroys it on leave.

Selectable visual skin for <cngx-tab-group>.
The skin is a pure thematic concern - every value renders the same tablist / tab / tabpanel structure, slots, ARIA, and keyboard behaviour, and only redirects CSS via the [data-skin] host attribute. 'line' (default) is the underline indicator; 'contained' fuses the active tab with the panel surface; 'segmented' sits the tabs in a muted track and lifts the active tab onto a raised surface; 'pill' renders rounded solid fills; 'pill-outline' renders the same pill geometry with a tinted, outlined active state instead of a solid fill.

Sized to the tab use cases - not a 1:1 copy of the stepper's seven skins. The Material twin ([cngxMatTabs]) ignores this setting.

Factory signature for CNGX_TAB_OVERFLOW_DOM_ADAPTER_FACTORY.

Async-commit action shape for tab transitions.
Receives origin and target indices; resolves true to commit, false to refuse. Observable | Promise | sync union mirrors the rest of the CNGX commit-action family.

Factory signature for CNGX_TABS_COMMIT_HANDLER_FACTORY. Override to wrap the default with retry-with-backoff, telemetry, or offline queues.

Union of feature kinds the tabs aggregator accepts.
Today: config and i18n; future surfaces widen the union and dispatch via the hidden _target discriminator.

Branded feature-fn for provideTabsI18n and provideCngxTabs. The hidden _target discriminator routes i18n features to provideTabsI18n and config features to provideTabsConfig from the unified aggregator.

Semantic colour key. The five named values cascade through the matching --cngx-tag-{name}-bg/-color/-border custom properties with English-readable fallback hex values (see tag.css).

Open-ended (string & {}) accepts any consumer-defined palette key (e.g. 'my-brand'); the directive emits it as a data-color attribute so consumers can author [data-color="my-brand"] styles against their own design tokens. Re-evaluation trigger toward a withTagColors() cascade is tracked in display-accepted-debt.md §1.

Density. md is the default. Each step scales padding + font-size via the --cngx-tag-{sm|lg|xl}-padding and matching font-size custom properties (see tag.css). Sizing of nested atoms (cngx-icon, cngx-avatar) is the consumer's call - Tag does not cascade a sub-token contract.

Visual variant. filled is the default solid pill; outline swaps fill for border; subtle softens both.

Discriminated-union shape returned by withTagDefaults / withTagGroupDefaults / withTagColors / withTagSlots. The reducer in provideTagConfig / provideTagConfigAt matches on kind and merges payload into the corresponding config sub-tree.

Mirrors the CngxSelectConfigFeature discriminated-union shape from @cngx/forms/select so the consumer's mental model is one across feature areas.

Cross-axis distribution of projected tags within the flex-wrap row. Resolves to a justify-content value:

• start (default) → flex-start
• center → center
• end → flex-end
• between → space-between

Only meaningful when the group has more horizontal room than its intrinsic content; otherwise the row hugs its tags.

Spacing between projected tags. Maps to the --cngx-tag-group-gap{,-xs,-md} CSS custom property cascade with fallback defaults (see tag-group.component.css). sm is the default - matches the tag's own padding rhythm.

• xs → 0.25rem (tight chip strips)
• sm → 0.5rem (default)
• md → 0.75rem (roomy taxonomy clusters)

Factory signature for CNGX_TEMPLATE_REGISTRY_FACTORY.

Factory signature carried by the DI token.

Action reported on CngxTreeSelectChange.action. Split out for switch-style narrowing without importing the change interface.

• 'toggle' - single node flipped.
• 'cascade-toggle' - parent toggle propagated to all descendants atomically (requires [cascadeChildren]="true").
• 'clear' - full selection cleared.

Factory signature for CNGX_TRIGGER_FOCUS_FACTORY.

Signature matching @floating-ui/dom computePosition. The consumer provides the actual function - the library never imports it directly.

Pure, framework-agnostic helpers that turn a signed delta value into the three orthogonal signals a KPI atom renders: direction (which way the arrow points), sentiment (whether the change is good or bad, which drives colour and the SR word), and the formatted magnitude.

Direction and sentiment are deliberately separate. CngxTrend colours by direction (up = green); CngxDelta colours by sentiment, so a value that dropped can still read as an improvement (churn down, latency down). Both consume these helpers so the direction / glyph / format logic has a single source of truth (Pillar 1) with no Angular dependency.

Percent (default, one fraction digit + %) or a locale-formatted absolute number.

How to read the sign of a delta. neutral disables sentiment entirely (direction still renders, colour stays neutral).

Good / bad / indifferent, derived from direction × polarity.

Lifecycle states of a CngxDialog.

Resting size tier of a rendered dot. Edge dots shrink (iOS page-control).

How the drawer panel interacts with the content area.

Position from which the drawer panel slides in.

Reason why a card grid is empty — drives empty-state template selection.

Custom error visibility strategy. Returns true when errors should be visible to the user.

Built-in error visibility strategies used by withErrorStrategy.

Editor-type discriminator. Used as the key into CNGX_FILTER_EDITORS. The library ships defaults for the four builtin keys ('string', 'number', 'date', 'boolean'); consumers add custom editor types freely.

Discriminated union - every node in the tree is either a group or an expression.

Function that formats a raw value for display.

Function that parses a display value back to raw.

A minimal EventTarget surface — only what the gate installs. Accepting this narrow shape (rather than a concrete Document) keeps the factory inject-free and trivially fakeable in a spec.

A feature function that contributes to the input config.

Allowed-character pattern for CngxInputFilter. The three string presets cover the common cases; a RegExp must match a single allowed character (it is tested per code point, not against the whole string).

Reads the X value of a data row at index i. Default behaviour (when omitted on a builder) is the row's positional index.

Reads the Y value of a data row at index i.

Matcher function used by CngxListboxSearch to filter options.

Visual variant for the loading indicator.

Built-in mask-preset table keys. date covers both the long and short date tables (they ship in one module).

Map of single-char token names to their definitions.

Config keys the four nav segments label their button with.

Visual variant for the nav badge.

One slot in the rendered page row: a page button or a truncation gap.

Per-region map of the national-number prefixes that identify each line type. This carries the consumer's own numbering data only - cngx ships none, in line with CngxPhoneMetadata keeping numbering metadata out of the library.

A single national-prefix rule: a literal prefix matched with startsWith ('0664' minus the trunk 0 is '664'), or a RegExp matched against the start of the national digits (/^1[567]/). Only start-anchored matches count as a prefix; a RegExp that matches mid-number is ignored.

Visual variant for the action button.

Feature function signature for providePopoverPanel().

Visual variant for the progress indicator.

Generic scale function shape. Maps a domain value of type TIn to a range value (typically a pixel coordinate). Mirrors the result type of every create*Scale factory in @cngx/common/chart.

Numeric input shape every concrete scale accepts. Linear scales take number, time scales take Date | number, band scales take string or arbitrary references via createBandScale's generic. The union narrows at the layer atom ([cngxLine], [cngxBar], ...); the chart context surface stays scale-agnostic.

Reads the data-space X value of a scatter row at index i.

Reads the data-space Y value of a scatter row at index i.

State of a single segment in a CngxSegmentedProgress.

How the sidenav interacts with the content area.

• 'over' - floats above content (overlay + backdrop)
• 'push' - pushes content aside when open
• 'side' - always visible, content permanently offset
• 'mini' - collapsed icon rail (miniWidth), expands to full width on hover

Logical position - flips in RTL.

Cross-axis alignment for CngxStack.

Main-axis direction for CngxStack.

Spacing scale for CngxStack. Maps to --cngx-gap-* tokens.

Semantic health of a CngxStatus.

Axis a swipe gesture is allowed to register on. 'x' accepts left/right, 'y' accepts up/down, 'both' accepts any dominant axis.

Swipe direction - matches drawer positions for natural composition.

Position for the toast stack.