import * as _angular_core from '@angular/core';
import { TemplateRef } from '@angular/core';

/**
 * `<sd-view>` — pure read-only display of a value (text, hyperlink, or a custom template).
 *
 * Presentational proxy with no state of its own: the parent form control (`<sd-select>`,
 * `<sd-input>`, …) computes the display string + resolved selection and passes them in;
 * `<sd-view>` only decides WHICH template renders. It is the single rendering path for every
 * "viewed" state across the form controls (DETAIL `viewed=true` and the `viewed='inline'`
 * text face), so a custom `valueTemplate` (e.g. `sdViewDef` / `#sdValue`) looks identical in
 * both. OnPush — re-renders only when an input signal changes.
 */
declare class SdView {
    /** Optional label rendered above the value (omitted when a parent supplies its own label). */
    label: _angular_core.InputSignal<string | null | undefined>;
    /** Raw selected value — NOT rendered directly; only exposed in the `valueTemplate` context as `value`. */
    value: _angular_core.InputSignal<any>;
    /**
     * Display string — what shows when no custom value template is bound.
     * why: `input.required()` forces the parent to bind `[display]` (compile error otherwise),
     * so the component never has to guess a fallback string from `value`.
     */
    display: _angular_core.InputSignal<unknown>;
    /** When set, the value renders as a link (`<a [sdHref]>`) instead of plain text. */
    hyperlink: _angular_core.InputSignal<string | null | undefined>;
    /** Label template handed down by a parent control (wins over `label` + `#sdLabel`). */
    labelTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    /** Value template handed down by a parent control (wins over `display` + `#sdValue`). */
    valueTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    /**
     * Resolved selected-item objects passed by the parent (e.g. `<sd-select>`).
     * why: the parent owns option/lazy resolution — `<sd-view>` is a proxy and must NOT rebuild
     * the list. Exposed in the value-template context so a "head +N" template can read `displayField`.
     */
    selectedItems: _angular_core.InputSignal<any[] | undefined>;
    /** `#sdLabel` template projected directly into `<sd-view>` (fallback when no `[labelTemplate]`). */
    contentLabelTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** `#sdValue` template projected directly into `<sd-view>` (fallback when no `[valueTemplate]`). */
    contentValueTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /**
     * Effective label template: input from parent wins, else the projected `#sdLabel`.
     * why: `computed` caches the choice so the template's `@if (activeLabelTemplate())` doesn't
     * re-evaluate two content-child reads on every change-detection pass.
     */
    activeLabelTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** Effective value template: input from parent wins, else the projected `#sdValue`. Cached for the same reason. */
    activeValueTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdView, "sd-view", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": true; "isSignal": true; }; "hyperlink": { "alias": "hyperlink"; "required": false; "isSignal": true; }; "labelTemplate": { "alias": "labelTemplate"; "required": false; "isSignal": true; }; "valueTemplate": { "alias": "valueTemplate"; "required": false; "isSignal": true; }; "selectedItems": { "alias": "selectedItems"; "required": false; "isSignal": true; }; }, {}, ["contentLabelTemplate", "contentValueTemplate"], never, true, never>;
}

export { SdView };