@star-ng/ui 0.0.0-placeholder.0 → 0.1.0

package/types/star-ng-ui-core.d.ts

@@ -0,0 +1,310 @@
+import * as i0 from "@angular/core";
+import { EffectRef, EnvironmentProviders, InjectionToken, Injector, Provider } from "@angular/core";
+import { FormArray, FormGroup } from "@angular/forms";
+/** Text direction of an element: left-to-right or right-to-left. */
+export type StarDirection = 'ltr' | 'rtl';
+/**
+ * Text direction in force at one element. A `dir` attribute on the element or on an ancestor
+ * decides; with `dir="auto"` or no attribute the computed `direction` decides. The function
+ * reads the DOM each time it is called, so a handler that calls it follows a direction change at
+ * run time, and a part of the page that has its own `dir` attribute is respected.
+ *
+ * Controls use it in key handlers and pointer math: the horizontal arrow keys follow the visual
+ * direction, so in `rtl` the left arrow means "next".
+ */
+export declare function starDirectionOf(element: Element | null | undefined): StarDirection;
+/** `true` when the element is laid out right-to-left. See `starDirectionOf`. */
+export declare function starIsRtl(element: Element | null | undefined): boolean;
+/**
+ * Key of a keyboard event in "inline" terms: `'ArrowRight'` means toward the end of the line and
+ * `'ArrowLeft'` toward the start, whatever the direction. In right-to-left the two arrow keys are
+ * swapped; every other key is returned as it is. A handler can then be written once, as for
+ * left-to-right text:
+ *
+ * ```ts
+ * switch (starInlineKey(event)) {
+ *   case 'ArrowRight': // next item in reading order
+ * }
+ * ```
+ *
+ * The element decides the direction; it defaults to `event.currentTarget`.
+ */
+export declare function starInlineKey(event: KeyboardEvent, element?: Element | null): string;
+/**
+ * Direction of the application: the `dir` attribute of `<html>` (or `<body>`), followed at run
+ * time. Controls that open an overlay or a menu (CDK `Overlay`, `CdkMenu`) inject it. It does
+ * two things:
+ *
+ * 1. `value` is a signal, so a control can react when the application switches the direction.
+ * 2. It keeps the root `Directionality` of `@angular/cdk/bidi` in step with the page. That
+ *    service reads the attribute once when it is created; without this, overlays and menus
+ *    would keep the old direction after a switch.
+ *
+ * The application only sets `dir` on `<html>`: `document.documentElement.dir = 'rtl'`.
+ */
+export declare class StarDirectionService {
+  private readonly document;
+  private readonly directionality;
+  private readonly current;
+  /** The direction of the page now. */
+  readonly value: import("@angular/core").Signal<StarDirection>;
+  constructor();
+  /** Reads the attribute again. The observer calls it; call it by hand after a change that the observer cannot see. */
+  refresh(): void;
+  private read;
+  private sync;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarDirectionService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Starts `StarDirectionService` when the application starts. Optional: the controls that open
+ * an overlay start the service themselves. Use it when the direction changes at run time before
+ * any such control exists, or when your own code reads `StarDirectionService.value`.
+ *
+ * ```ts
+ * bootstrapApplication(App, { providers: [provideStarDirection()] });
+ * ```
+ */
+export declare function provideStarDirection(): EnvironmentProviders;
+/**
+ * How a list control reads a property from an option: a property name or an accessor function.
+ * Same idea as PrimeNG `optionLabel` / `optionValue` / `optionDisabled`, but type safe.
+ */
+export type StarOptionKey<T, R = unknown> = (keyof T & string) | ((option: T) => R);
+export type StarSeverity = 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger';
+export type StarSize = 'sm' | 'md' | 'lg';
+export declare function readOption<T, R>(option: T, key: StarOptionKey<T, R> | null | undefined): unknown;
+/** Text shown for an option. Falls back to the option itself for primitive options. */
+export declare function optionText<T>(option: T, key: StarOptionKey<T> | null | undefined): string;
+/** Locale-aware compare used by sorting: numbers and dates numerically, text with Intl.Collator. */
+export declare function compareValues(a: unknown, b: unknown): number;
+/** Case- and accent-insensitive "contains" match used by filters. */
+export declare function matchesFilter(text: string, query: string): boolean;
+/**
+ * Keeps a Reactive `FormGroup` (or `FormArray`) in step with the `SignalFormControl`s inside it.
+ *
+ * Angular 22 updates a parent group when a `SignalFormControl` value changes, but not when a
+ * Signal Forms rule (for example `disabled({ when })` or a conditional `required`) changes the
+ * child's status without a value change. The group then reports a stale `valid` / `status`.
+ * This effect watches every signal control's validity, disabled and pending state and calls
+ * `updateValueAndValidity()` on the group when one changes.
+ *
+ * Call it in an injection context (a field initializer or constructor):
+ * ```ts
+ * readonly form = new FormGroup({ country: new SignalFormControl<string | null>(null, rules) });
+ * private readonly sync = syncSignalFormControls(this.form);
+ * ```
+ */
+export declare function syncSignalFormControls(group: FormGroup | FormArray, injector?: Injector): EffectRef;
+/**
+ * Built-in texts of the StarNG UI controls (screen-reader labels, empty states, reports).
+ * Defaults are English. Override them once at app level:
+ * - `provideStarUiTextFromTransloco()` reads them from the active Transloco language (`ui.*` keys)
+ *   and updates the controls live when the language changes.
+ * - `provideStarUiText({...})` sets fixed texts.
+ *
+ * Function entries take values (for example a count) and return the full sentence, so word order
+ * can change per language. Their parameter names are listed in `STAR_UI_TEXT_PARAMS`.
+ */
+export interface StarUiText {
+  readonly close: string;
+  readonly clear: string;
+  readonly loading: string;
+  readonly actions: string;
+  readonly moreActions: string;
+  readonly ofTotal: (index: number, total: number) => string;
+  readonly expandItem: (label: string) => string;
+  readonly collapseItem: (label: string) => string;
+  readonly removeItem: (label: string) => string;
+  readonly tagsHint: string;
+  readonly tagAdded: (label: string) => string;
+  readonly tagRemoved: (label: string) => string;
+  readonly tagInvalid: (label: string) => string;
+  readonly tagDuplicate: (label: string) => string;
+  readonly tagLimit: (max: number) => string;
+  readonly notifications: string;
+  readonly accept: string;
+  readonly reject: string;
+  readonly selectPlaceholder: string;
+  readonly filterPlaceholder: string;
+  readonly emptyMessage: string;
+  readonly emptyFilterMessage: string;
+  readonly selectAll: string;
+  readonly selectedItems: (count: number) => string;
+  readonly searching: string;
+  readonly showOptions: string;
+  readonly resultsAvailable: (count: number) => string;
+  readonly pagination: string;
+  readonly firstPage: string;
+  readonly previousPage: string;
+  readonly nextPage: string;
+  readonly lastPage: string;
+  readonly page: (page: number) => string;
+  readonly rowsPerPage: string;
+  readonly pageReport: (first: number, last: number, total: number) => string;
+  readonly noData: string;
+  readonly selectRow: string;
+  readonly selectAllRows: string;
+  readonly filterBy: (column: string) => string;
+  readonly filterAll: string;
+  readonly filterMin: (column: string) => string;
+  readonly filterMax: (column: string) => string;
+  readonly filterMinShort: string;
+  readonly filterMaxShort: string;
+  readonly expandRow: string;
+  readonly collapseRow: string;
+  readonly rowDetails: string;
+  readonly reorderRows: string;
+  readonly sortMultiHint: string;
+  readonly terminalCommand: string;
+  readonly compareImages: string;
+  readonly editCell: (column: string) => string;
+  readonly columns: string;
+  readonly resizeColumn: (column: string) => string;
+  readonly moveColumnEarlier: (column: string) => string;
+  readonly moveColumnLater: (column: string) => string;
+  readonly layout: string;
+  readonly layoutList: string;
+  readonly layoutGrid: string;
+  readonly moveSelectedItem: string;
+  readonly orderListHint: string;
+  readonly moveTop: string;
+  readonly moveUp: string;
+  readonly moveDown: string;
+  readonly moveBottom: string;
+  readonly itemPosition: (label: string, position: number, total: number) => string;
+  readonly transfer: string;
+  readonly moveSelectedToTarget: string;
+  readonly moveAllToTarget: string;
+  readonly moveSelectedToSource: string;
+  readonly moveAllToSource: string;
+  readonly pickListSource: string;
+  readonly pickListTarget: string;
+  readonly chooseDate: string;
+  readonly chooseMonth: string;
+  readonly chooseYear: string;
+  readonly previousMonth: string;
+  readonly nextMonth: string;
+  readonly previousYears: string;
+  readonly nextYears: string;
+  readonly today: string;
+  readonly time: string;
+  readonly startTime: string;
+  readonly weekNumber: string;
+  readonly weekShort: string;
+  readonly endTime: string;
+  readonly done: string;
+  readonly increase: string;
+  readonly decrease: string;
+  readonly showPassword: string;
+  readonly hidePassword: string;
+  readonly passwordWeak: string;
+  readonly passwordFair: string;
+  readonly passwordGood: string;
+  readonly passwordStrong: string;
+  readonly passwordRuleLength: (min: number) => string;
+  readonly passwordRuleUpper: string;
+  readonly passwordRuleLower: string;
+  readonly passwordRuleNumber: string;
+  readonly passwordRuleSymbol: string;
+  readonly ruleMet: string;
+  readonly ruleNotMet: string;
+  readonly otpLabel: string;
+  readonly otpCharacter: (position: number, total: number) => string;
+  readonly ratingLabel: string;
+  readonly sliderMinimum: (label: string) => string;
+  readonly sliderMaximum: (label: string) => string;
+  readonly colorLabel: string;
+  readonly customColor: string;
+  readonly hexValue: (label: string) => string;
+  readonly chooseFiles: string;
+  readonly dropFiles: string;
+  readonly fileMaxSize: (size: string) => string;
+  readonly fileUpTo: (count: number) => string;
+  readonly uploadingFile: (name: string) => string;
+  readonly uploaded: string;
+  readonly fileTypeNotAllowed: (name: string) => string;
+  readonly fileTooLarge: (name: string, max: string) => string;
+  readonly fileLimitReached: (limit: number) => string;
+  readonly editorLabel: string;
+  readonly editorFormatting: (label: string) => string;
+  readonly editorBold: string;
+  readonly editorItalic: string;
+  readonly editorUnderline: string;
+  readonly editorHeading: string;
+  readonly editorBulletList: string;
+  readonly editorNumberedList: string;
+  readonly editorClearFormatting: string;
+  readonly editorLink: string;
+  readonly editorLinkPrompt: string;
+  readonly breadcrumb: string;
+  readonly stepperLabel: string;
+  readonly stepCompleted: string;
+  readonly resizePanes: string;
+  readonly dock: string;
+  readonly scrollToTop: string;
+  readonly theme: string;
+  readonly themeSystem: string;
+  readonly themeLight: string;
+  readonly themeDark: string;
+  readonly pauseSlides: string;
+  readonly playSlides: string;
+  readonly previousSlides: string;
+  readonly nextSlides: string;
+  readonly galleryLabel: string;
+  readonly previousImage: string;
+  readonly nextImage: string;
+  readonly showImage: (alt: string) => string;
+  readonly previewImage: (alt: string) => string;
+  readonly zoomIn: string;
+  readonly zoomOut: string;
+  readonly chartView: string;
+  readonly tableView: string;
+  readonly chartTotal: string;
+  readonly chartOther: string;
+  readonly chartCategory: string;
+  readonly chartValue: string;
+  readonly chartShare: string;
+  readonly chartSeries: string;
+  readonly chartX: string;
+  readonly chartY: string;
+  readonly chartTypeBar: string;
+  readonly chartTypeStackedBar: string;
+  readonly chartTypeLine: string;
+  readonly chartTypeArea: string;
+  readonly chartTypeDoughnut: string;
+  readonly chartTypePie: string;
+  readonly chartTypeRadar: string;
+  readonly chartTypePolarArea: string;
+  readonly chartTypeScatter: string;
+  readonly chartDescription: (kind: string, series: number, items: number, min: string, max: string) => string;
+  readonly meterValue: (value: string, total: number) => string;
+}
+export declare const STAR_UI_TEXT_DEFAULTS: StarUiText;
+/** Parameter names of the function entries, in call order (used for `{{ name }}` in translations). */
+export declare const STAR_UI_TEXT_PARAMS: { readonly [K in keyof StarUiText]?: readonly string[]; };
+export declare const STAR_UI_TEXT: InjectionToken<StarUiText>;
+/** Overrides some or all built-in control texts with fixed values. */
+export declare function provideStarUiText(overrides: Partial<StarUiText>): Provider;
+/**
+ * Builds a `StarUiText` whose entries read `source()` on every access. When `source` reads a
+ * signal, every OnPush control that renders a built-in text updates when that signal changes.
+ * Entries that `source()` does not return fall back to the English default.
+ *
+ * Use it in a factory when the signal lives in a service:
+ * `{ provide: STAR_UI_TEXT, useFactory: () => starUiTextFromSignal(inject(Language).text) }`.
+ */
+export declare function starUiTextFromSignal(source: () => Partial<StarUiText>): StarUiText;
+/**
+ * Provides the control texts from a function that reads a signal, so the language can change at
+ * run time without a translation library:
+ *
+ * ```ts
+ * const language = signal<'en' | 'de'>('en');
+ * provideStarUiTextFromSignal(() => (language() === 'de' ? STAR_UI_TEXT_DE : STAR_UI_TEXT_DEFAULTS));
+ * ```
+ *
+ * Do not spread a pack with getters into an object (`{ ...text }`): that reads every getter once and
+ * freezes the result. Pass a function, as shown above.
+ */
+export declare function provideStarUiTextFromSignal(source: () => Partial<StarUiText>): Provider;

package/types/star-ng-ui-data-display.d.ts

@@ -0,0 +1,339 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { StarOptionKey } from "@star-ng/ui/core";
+import { StarTreeNode } from "@star-ng/ui/tree";
+export interface StarTreeTableColumn {
+  readonly field: string;
+  readonly header: string;
+  readonly width?: string;
+  readonly align?: 'start' | 'center' | 'end';
+}
+interface TreeRow {
+  readonly node: StarTreeNode<Record<string, unknown>>;
+  readonly level: number;
+  readonly setSize: number;
+  readonly position: number;
+}
+/**
+ * Tree table (PrimeNG `p-treetable`): hierarchical rows with expand / collapse in a table,
+ * `role="treegrid"`, Right / Left on a row expand / collapse, Up / Down move between rows.
+ * Node `data` holds the column values; the first column shows the tree toggle.
+ *
+ * `<star-tree-table [nodes]="budget" [columns]="cols" [(expanded)]="open" ariaLabel="Budget" />`
+ */
+export declare class StarTreeTable {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  readonly nodes: import("@angular/core").InputSignal<readonly StarTreeNode<Record<string, unknown>>[]>;
+  readonly columns: import("@angular/core").InputSignal<readonly StarTreeTableColumn[]>;
+  readonly expanded: import("@angular/core").ModelSignal<readonly string[]>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly rows: import("@angular/core").Signal<TreeRow[]>;
+  protected readonly focusKey: import("@angular/core").WritableSignal<string | null>;
+  protected isOpen(key: string): boolean;
+  toggle(key: string, open?: boolean): void;
+  protected onKeydown(event: KeyboardEvent, row: TreeRow): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarTreeTable, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarTreeTable, "star-tree-table", never, {
+    "nodes": {
+      "alias": "nodes";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "expanded": {
+      "alias": "expanded";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "expanded": "expandedChange";
+  }, never, never, true, never>;
+}
+/** Item template: `<ng-template starDataViewItem let-item let-layout="layout">`. */
+export declare class StarDataViewItem<T = unknown> {
+  readonly starDataViewItemOf: import("@angular/core").InputSignal<readonly T[] | null>;
+  readonly template: TemplateRef<{
+    $implicit: T;
+    layout: "list" | "grid";
+    index: number;
+  }>;
+  static ngTemplateContextGuard<T>(_dir: StarDataViewItem<T>, _ctx: unknown): _ctx is {
+    $implicit: T;
+    layout: 'list' | 'grid';
+    index: number;
+  };
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarDataViewItem<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StarDataViewItem<any>, "ng-template[starDataViewItem]", never, {
+    "starDataViewItemOf": {
+      "alias": "starDataViewItemOf";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Data view (PrimeNG `p-dataview`): items in a list or a responsive grid, layout switch,
+ * client pagination and an empty state. It does not sort: sort the items before you pass them in.
+ * You design each item with a template.
+ *
+ * ```html
+ * <star-data-view [items]="products" [(layout)]="layout" paginator [rows]="6">
+ *   <ng-template starDataViewItem let-p let-layout="layout">…</ng-template>
+ * </star-data-view>
+ * ```
+ */
+export declare class StarDataView<T = unknown> {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  protected readonly layouts: ({
+    id: "list";
+    label: string;
+    icon: string;
+  } | {
+    id: "grid";
+    label: string;
+    icon: string;
+  })[];
+  readonly items: import("@angular/core").InputSignal<readonly T[]>;
+  readonly layout: import("@angular/core").ModelSignal<"list" | "grid">;
+  readonly paginator: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly rows: import("@angular/core").ModelSignal<number>;
+  readonly first: import("@angular/core").ModelSignal<number>;
+  readonly emptyMessage: import("@angular/core").InputSignal<string | null>;
+  protected readonly itemTemplate: import("@angular/core").Signal<StarDataViewItem<any> | undefined>;
+  protected readonly pageItems: import("@angular/core").Signal<readonly T[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarDataView<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarDataView<any>, "star-data-view", never, {
+    "items": {
+      "alias": "items";
+      "required": false;
+      "isSignal": true;
+    };
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginator": {
+      "alias": "paginator";
+      "required": false;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": false;
+      "isSignal": true;
+    };
+    "first": {
+      "alias": "first";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyMessage": {
+      "alias": "emptyMessage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "layout": "layoutChange";
+    "rows": "rowsChange";
+    "first": "firstChange";
+  }, ["itemTemplate"], ["[starDataViewHeader]"], true, never>;
+}
+/**
+ * Order list (PrimeNG `p-orderlist`): reorder items with buttons or Alt + Arrow keys; the moved
+ * item keeps focus and a live region announces its new position.
+ * `<star-order-list [(value)]="priorities" optionLabel="name" ariaLabel="Queue order" />`
+ */
+export declare class StarOrderList<T = unknown> {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  protected readonly hintId: string;
+  readonly value: import("@angular/core").ModelSignal<readonly T[]>;
+  readonly optionLabel: import("@angular/core").InputSignal<StarOptionKey<T> | null>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly selected: import("@angular/core").WritableSignal<number>;
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected readonly actions: ({
+    id: "top";
+    label: string;
+    icon: string;
+  } | {
+    id: "up";
+    label: string;
+    icon: string;
+  } | {
+    id: "down";
+    label: string;
+    icon: string;
+  } | {
+    id: "bottom";
+    label: string;
+    icon: string;
+  })[];
+  protected labelOf(item: T): string;
+  protected canMove(direction: 'top' | 'up' | 'down' | 'bottom'): boolean;
+  move(direction: 'top' | 'up' | 'down' | 'bottom'): void;
+  protected onKeydown(event: KeyboardEvent, index: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarOrderList<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarOrderList<any>, "star-order-list", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "optionLabel": {
+      "alias": "optionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * Pick list (PrimeNG `p-picklist`): move items between a source and a target list.
+ * Double-click or Enter moves one item; buttons move the selection or everything.
+ * `<star-pick-list [(source)]="available" [(target)]="assigned" optionLabel="name" sourceHeader="Available" targetHeader="Assigned" />`
+ */
+export declare class StarPickList<T = unknown> {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  private readonly idGen;
+  protected readonly ids: {
+    source: string;
+    target: string;
+  };
+  protected readonly sides: readonly ["source", "target"];
+  readonly source: import("@angular/core").ModelSignal<readonly T[]>;
+  readonly target: import("@angular/core").ModelSignal<readonly T[]>;
+  readonly optionLabel: import("@angular/core").InputSignal<StarOptionKey<T> | null>;
+  readonly sourceHeader: import("@angular/core").InputSignal<string | null>;
+  readonly targetHeader: import("@angular/core").InputSignal<string | null>;
+  private readonly selection;
+  protected labelOf(item: T): string;
+  protected picked(side: 'source' | 'target'): readonly T[];
+  protected isPicked(side: 'source' | 'target', item: T): boolean;
+  protected pick(side: 'source' | 'target', item: T): void;
+  transfer(from: 'source' | 'target', items: readonly T[]): void;
+  /** Reads a value with an optional key (exposed for custom templates). */
+  read(item: T, key: StarOptionKey<T>): unknown;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarPickList<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarPickList<any>, "star-pick-list", never, {
+    "source": {
+      "alias": "source";
+      "required": false;
+      "isSignal": true;
+    };
+    "target": {
+      "alias": "target";
+      "required": false;
+      "isSignal": true;
+    };
+    "optionLabel": {
+      "alias": "optionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sourceHeader": {
+      "alias": "sourceHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "targetHeader": {
+      "alias": "targetHeader";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "source": "sourceChange";
+    "target": "targetChange";
+  }, never, never, true, never>;
+}
+export interface StarOrgNode<T = unknown> {
+  /** Unique id of the node in the chart. */
+  readonly key: string;
+  readonly label: string;
+  /** Second line, for example a role. */
+  readonly subtitle?: string;
+  readonly data?: T;
+  readonly children?: readonly StarOrgNode<T>[];
+}
+export interface StarOrgNodeContext<T> {
+  readonly $implicit: StarOrgNode<T>;
+  readonly level: number;
+}
+/** Custom node content: `<ng-template starOrgNode let-node>…</ng-template>`. */
+export declare class StarOrgNodeTemplate<T = unknown> {
+  readonly template: TemplateRef<StarOrgNodeContext<T>>;
+  static ngTemplateContextGuard<T>(_dir: StarOrgNodeTemplate<T>, _ctx: unknown): _ctx is StarOrgNodeContext<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarOrgNodeTemplate<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StarOrgNodeTemplate<any>, "ng-template[starOrgNode]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Organization chart (PrimeNG `p-organizationchart`): a hierarchy drawn top-down with
+ * connector lines. The markup is a nested list, so assistive technology reads the levels.
+ * A node with children has a button that hides or shows its branch.
+ *
+ * `<star-org-chart ariaLabel="Safety team" [value]="team" [(collapsedKeys)]="closed" selectable />`
+ */
+export declare class StarOrgChart<T = unknown> {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  /** Root node of the chart. */
+  readonly value: import("@angular/core").InputSignal<StarOrgNode<T>>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  /** Keys of the nodes whose branch is hidden. Two-way. */
+  readonly collapsedKeys: import("@angular/core").ModelSignal<readonly string[]>;
+  /** Nodes are buttons; one node can be selected. */
+  readonly selectable: import("@angular/core").InputSignalWithTransform<boolean, boolean | "">;
+  readonly selectedKey: import("@angular/core").ModelSignal<string | null>;
+  readonly nodeSelect: import("@angular/core").OutputEmitterRef<StarOrgNode<T>>;
+  protected readonly nodeTemplate: import("@angular/core").Signal<StarOrgNodeTemplate<any> | undefined>;
+  protected isCollapsed(node: StarOrgNode<T>): boolean;
+  protected toggle(node: StarOrgNode<T>): void;
+  protected select(node: StarOrgNode<T>): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarOrgChart<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarOrgChart<any>, "star-org-chart", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapsedKeys": {
+      "alias": "collapsedKeys";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectedKey": {
+      "alias": "selectedKey";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "collapsedKeys": "collapsedKeysChange";
+    "selectedKey": "selectedKeyChange";
+    "nodeSelect": "nodeSelect";
+  }, ["nodeTemplate"], never, true, never>;
+}
+export {};