@hyalo/angular 0.0.0-stage → 0.1.0

package/types/hyalo-angular-interaction.d.ts

@@ -0,0 +1,131 @@
+import * as i0 from "@angular/core";
+/** Where a revealed element comes from. */
+export type HyRevealFrom = 'up' | 'fade' | 'scale';
+/**
+ * Fades and lifts an element in when it scrolls into view.
+ *
+ * ```html
+ * @for (item of items; track item.id; let i = $index) {
+ *   <article hyReveal [revealDelay]="i * 60">...</article>
+ * }
+ * ```
+ *
+ * Content is never hidden by default. The directive only hides an element
+ * after hydration, only when it is below the fold, and only when motion is
+ * enabled. Elements already on screen are left alone, so server-rendered
+ * content does not flash. CSS transitions do the work, so it also runs on the
+ * low tier when reduced motion is off.
+ *
+ * Put it on the glass element itself (`<hy-card hyReveal>`), not on a
+ * wrapper around glass. While a wrapper fades, its glass children cannot
+ * blur what is behind it, and the blur snaps in when the fade ends.
+ */
+export declare class HyReveal {
+  private readonly el;
+  private readonly motion;
+  /** Delay in milliseconds, for staggering. */
+  readonly revealDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** The starting pose. */
+  readonly revealFrom: import("@angular/core").InputSignal<HyRevealFrom>;
+  /** Reveal again each time the element re-enters the viewport. */
+  readonly revealRepeat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyReveal, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyReveal, "[hyReveal]", never, {
+    "revealDelay": {
+      "alias": "revealDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "revealFrom": {
+      "alias": "revealFrom";
+      "required": false;
+      "isSignal": true;
+    };
+    "revealRepeat": {
+      "alias": "revealRepeat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Tilts the element toward the cursor and moves a soft glow under it.
+ *
+ * ```html
+ * <hy-card hyTilt [tiltMax]="8">...</hy-card>
+ * ```
+ *
+ * Runs only with a fine pointer, with motion enabled and above the low
+ * fidelity tier. The glow uses `--hy-px`, `--hy-py` and `--hy-glow`, which the
+ * glass material already reads.
+ */
+export declare class HyTilt {
+  private readonly el;
+  private readonly motion;
+  /** Maximum rotation in degrees. */
+  readonly tiltMax: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Whether to show the pointer glow. */
+  readonly tiltGlow: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTilt, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyTilt, "[hyTilt]", never, {
+    "tiltMax": {
+      "alias": "tiltMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "tiltGlow": {
+      "alias": "tiltGlow";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Pulls the element a little toward the cursor while it hovers.
+ *
+ * Uses the `translate` property, so it never fights with a `transform` the
+ * element already has.
+ */
+export declare class HyMagnetic {
+  private readonly el;
+  private readonly motion;
+  /** How far the element follows the cursor, as a share of the distance. */
+  readonly magneticStrength: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Upper limit for the offset in pixels. */
+  readonly magneticMax: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMagnetic, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyMagnetic, "[hyMagnetic]", never, {
+    "magneticStrength": {
+      "alias": "magneticStrength";
+      "required": false;
+      "isSignal": true;
+    };
+    "magneticMax": {
+      "alias": "magneticMax";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * A soft light ripple from the press point. Purely decorative: it is
+ * skipped with reduced motion and never affects layout.
+ */
+export declare class HyRipple {
+  private readonly el;
+  private readonly motion;
+  /** Turns the ripple off without removing the directive. */
+  readonly rippleDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyRipple, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyRipple, "[hyRipple]", never, {
+    "rippleDisabled": {
+      "alias": "rippleDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/hyalo-angular-navbar.d.ts

@@ -0,0 +1,110 @@
+import * as i0 from "@angular/core";
+/** The logo or product name, at the start of the bar. */
+export declare class HyNavbarBrand {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbarBrand, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyNavbarBrand, "[hyNavbarBrand]", never, {}, {}, never, never, true, never>;
+}
+/** Buttons at the end of the bar, such as sign in or a cart. Always visible. */
+export declare class HyNavbarActions {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbarActions, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyNavbarActions, "[hyNavbarActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * - `floating`: a detached glass pill with space around it.
+ * - `full`: a full-width bar. Once content scrolls under it, a soft fade
+ *   at its lower edge separates the two instead of a hard line.
+ */
+export type HyNavbarAppearance = 'floating' | 'full';
+/**
+ * A glass app bar. Links go in the default slot and are wrapped in a
+ * `<nav>`. On narrow screens they collapse behind a menu button and open as
+ * a panel under the bar. Bind `menuOpen` if you would rather open your own
+ * drawer.
+ *
+ * ```html
+ * <hy-navbar label="Main">
+ *   <a hyNavbarBrand routerLink="/">Atelier</a>
+ *   <a routerLink="/watches" routerLinkActive="active" ariaCurrentWhenActive="page">Watches</a>
+ *   <a routerLink="/journal">Journal</a>
+ *   <div hyNavbarActions><button hyButton size="sm">Book a visit</button></div>
+ * </hy-navbar>
+ * ```
+ *
+ * The bar compacts once the page scrolls, and with `hideOnScroll` it slides
+ * away while scrolling down and returns on the way up. It never hides while
+ * the menu is open or focus is inside it. The collapse point is a container
+ * query on the navbar's own width (48rem by default).
+ */
+export declare class HyNavbar {
+  private readonly toggle;
+  protected readonly linksId: string;
+  /** Accessible name of the `<nav>` landmark. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the menu button on narrow screens. */
+  readonly menuLabel: import("@angular/core").InputSignal<string>;
+  /** Visual style of the bar. */
+  readonly appearance: import("@angular/core").InputSignal<HyNavbarAppearance>;
+  /** CSS positioning of the navbar. */
+  readonly position: import("@angular/core").InputSignal<"sticky" | "fixed" | "static">;
+  /** Material of the bar. */
+  readonly material: import("@angular/core").InputSignal<"" | "clear" | "frosted" | "tinted" | "solid">;
+  /** Slide away while scrolling down. */
+  readonly hideOnScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scroll distance in pixels after which the bar compacts. */
+  readonly scrollThreshold: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Whether the collapsed menu is open. Two-way bindable. */
+  readonly menuOpen: import("@angular/core").ModelSignal<boolean>;
+  protected readonly scrolled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly hidden: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /** Closes the collapsed menu. */
+  closeMenu(restoreFocus?: boolean): void;
+  protected onClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyNavbar, "hy-navbar", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuLabel": {
+      "alias": "menuLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "appearance": {
+      "alias": "appearance";
+      "required": false;
+      "isSignal": true;
+    };
+    "position": {
+      "alias": "position";
+      "required": false;
+      "isSignal": true;
+    };
+    "material": {
+      "alias": "material";
+      "required": false;
+      "isSignal": true;
+    };
+    "hideOnScroll": {
+      "alias": "hideOnScroll";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollThreshold": {
+      "alias": "scrollThreshold";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuOpen": {
+      "alias": "menuOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "menuOpen": "menuOpenChange";
+  }, never, ["[hyNavbarBrand]", "*", "[hyNavbarActions]"], true, never>;
+}
+/** Everything needed to build a navbar. */
+export declare const HY_NAVBAR: readonly [typeof HyNavbar, typeof HyNavbarBrand, typeof HyNavbarActions];

package/types/hyalo-angular-overlay.d.ts

@@ -0,0 +1,31 @@
+import { ConnectedPosition } from "@angular/cdk/overlay";
+/**
+ * Where a floating element sits relative to its trigger. `start` and `end`
+ * follow the text direction, so `end` is on the right in LTR and on the left
+ * in RTL.
+ */
+export type HyPlacement = 'top' | 'bottom' | 'start' | 'end';
+/**
+ * CDK positions for a placement, with the opposite side as the first
+ * fallback when there is no room.
+ */
+export declare function hyConnectedPositions(placement: HyPlacement, offset?: number): ConnectedPosition[];
+/** Positions for a dropdown that lines up with the trigger's start edge. */
+export declare function hyDropdownPositions(offset?: number): ConnectedPosition[];
+/**
+ * @internal Enter and exit for small overlays (tooltips, popovers, select
+ * panels), driven by `data-state` and CSS transitions.
+ *
+ * Transitions start from the current value, so reopening a panel while it
+ * is still fading out simply turns it around, with no jump.
+ */
+declare class HyPresence {
+  private cancel;
+  /** True while an exit is playing. */
+  get leaving(): boolean;
+  /** Shows a panel that was just attached, or turns a leaving one around. */
+  enter(el: HTMLElement): void;
+  /** Plays the exit, then calls `done`, unless `enter` turns it around first. */
+  leave(el: HTMLElement, done: () => void): void;
+}
+export { HyPresence as ɵHyPresence };

package/types/hyalo-angular-popover.d.ts

@@ -0,0 +1,142 @@
+import { HyPlacement } from "@hyalo/angular/overlay";
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+export declare class HyTooltipPanel {
+  readonly message: import("@angular/core").WritableSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTooltipPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyTooltipPanel, "hy-tooltip-panel", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A short text hint on hover or keyboard focus.
+ *
+ * ```html
+ * <button hyButton iconOnly aria-label="Copy link" hyTooltip="Copy link">...</button>
+ * ```
+ *
+ * The text is also added to the trigger's `aria-describedby` through a
+ * hidden element, so screen readers get it without the visual tooltip. The
+ * tooltip stays open while the pointer is over it and closes on Escape, as
+ * WCAG 1.4.13 asks. Keep it short and never put interactive content in it;
+ * use `hyPopover` for that.
+ */
+export declare class HyTooltip {
+  private readonly injector;
+  private readonly host;
+  private readonly describer;
+  private overlayRef;
+  private position;
+  private panel;
+  private panelEl;
+  private readonly presence;
+  private showTimer;
+  private hideTimer;
+  /** True from show() until hide(), so a late overlay load knows to stop. */
+  private wanted;
+  private destroyed;
+  /** The tooltip text. */
+  readonly message: import("@angular/core").InputSignal<string>;
+  /** Preferred side. Flips when there is no room. */
+  readonly tooltipPlacement: import("@angular/core").InputSignal<HyPlacement>;
+  /** Hover delay in milliseconds. Focus shows it right away. */
+  readonly tooltipDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly tooltipDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  protected onPointerEnter(event: PointerEvent): void;
+  /** Shows the tooltip after the given delay. */
+  show(delay?: number): void;
+  /** Starts hiding the tooltip now. It fades out quickly. */
+  hide(): void;
+  protected scheduleHide(): void;
+  private attach;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyTooltip, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyTooltip, "[hyTooltip]", never, {
+    "message": {
+      "alias": "hyTooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipPlacement": {
+      "alias": "tooltipPlacement";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipDelay": {
+      "alias": "tooltipDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltipDisabled": {
+      "alias": "tooltipDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * A non-modal glass panel anchored to a trigger, for content that does not
+ * fit in a tooltip: a short form, a menu of links, details.
+ *
+ * ```html
+ * <button hyButton variant="glass" [hyPopover]="share" popoverLabel="Share">Share</button>
+ * <ng-template #share>
+ *   <a href="...">Copy link</a>
+ * </ng-template>
+ * ```
+ *
+ * Click or Enter toggles it. On open, focus moves to the first focusable
+ * element inside. Escape closes it and returns focus to the trigger, and so
+ * does clicking outside or tabbing out of it.
+ */
+export declare class HyPopover {
+  private readonly injector;
+  private readonly host;
+  private readonly viewContainer;
+  private readonly focusTraps;
+  private readonly fidelity;
+  protected readonly panelId: string;
+  private overlayRef;
+  private position;
+  private readonly presence;
+  private destroyed;
+  /** The content. */
+  readonly content: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  /** Accessible name of the panel. */
+  readonly popoverLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Preferred side. Flips when there is no room. */
+  readonly popoverPlacement: import("@angular/core").InputSignal<HyPlacement>;
+  /** Whether the panel is open. Two-way bindable as `[(popoverOpen)]`. */
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  constructor();
+  toggle(): void;
+  /** Closes the panel, optionally moving focus back to the trigger. */
+  close(restoreFocus?: boolean): void;
+  protected preload(): void;
+  private attach;
+  private detach;
+  private readonly onFocusOut;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyPopover, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyPopover, "[hyPopover]", ["hyPopover"], {
+    "content": {
+      "alias": "hyPopover";
+      "required": true;
+      "isSignal": true;
+    };
+    "popoverLabel": {
+      "alias": "popoverLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "popoverPlacement": {
+      "alias": "popoverPlacement";
+      "required": false;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "popoverOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "popoverOpenChange";
+  }, never, never, true, never>;
+}

package/types/hyalo-angular-segmented.d.ts

@@ -0,0 +1,79 @@
+import { FormValueControl } from "@angular/forms/signals";
+import { HySize } from "@hyalo/angular";
+import * as i0 from "@angular/core";
+/** One choice in a segmented control. */
+export interface HySegmentedOption<T> {
+  readonly value: T;
+  readonly label: string;
+  readonly icon?: string;
+  readonly disabled?: boolean;
+}
+/**
+ * A segmented control: a small set of mutually exclusive choices with the
+ * same sliding indicator as tabs. Use it to pick a value (billing period, a
+ * view mode). Use tabs when each choice shows a different panel.
+ *
+ * It is a group of native radio buttons, so arrow keys, form submission and
+ * screen readers behave as users expect. Works with Signal Forms through
+ * `[formField]`, or with `[(value)]`.
+ *
+ * ```html
+ * <hy-segmented label="Billing" [options]="periods" [(value)]="period" />
+ * ```
+ */
+export declare class HySegmented<T> implements FormValueControl<T | undefined> {
+  protected readonly groupName: string;
+  private readonly row;
+  private readonly items;
+  /** The choices. */
+  readonly options: import("@angular/core").InputSignal<readonly HySegmentedOption<T>[]>;
+  /** Selected value. Two-way bindable. */
+  readonly value: import("@angular/core").ModelSignal<T | undefined>;
+  /** Accessible name of the group. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Name shared by the radio inputs. Generated when not set. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Disables every option. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Control size. */
+  readonly size: import("@angular/core").InputSignal<HySize>;
+  /** Emits when focus leaves an option, so forms can mark the field touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly ready: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySegmented<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySegmented<any>, "hy-segmented", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}

package/types/hyalo-angular-select.d.ts

@@ -0,0 +1,130 @@
+import { FormValueControl } from "@angular/forms/signals";
+import { HyFieldControl } from "@hyalo/angular/field";
+import * as i0 from "@angular/core";
+/** One choice in a select. */
+export interface HySelectOption<T> {
+  readonly value: T;
+  readonly label: string;
+  readonly disabled?: boolean;
+}
+/**
+ * A single-choice select with a glass dropdown, built on Angular Aria's
+ * combobox and listbox patterns.
+ *
+ * ```html
+ * <hy-field label="Strap">
+ *   <hy-select [options]="straps" [formField]="form.strap" placeholder="Choose a strap" />
+ * </hy-field>
+ * ```
+ *
+ * Focus stays on the trigger while the list is open, and options are
+ * announced through `aria-activedescendant`. Arrow keys move, Enter or
+ * Space picks, Escape closes, and typing jumps to a matching option.
+ *
+ * On the low fidelity tier, or with `native`, it renders a real `<select>`
+ * instead. That gives the platform picker on phones and costs nothing.
+ */
+export declare class HySelect<T> implements FormValueControl<T | undefined>, HyFieldControl {
+  private readonly fidelity;
+  protected readonly field: import("@hyalo/angular/field").HyFieldContext | null;
+  private readonly trigger;
+  private readonly overlay;
+  private readonly presence;
+  /** The choices. */
+  readonly options: import("@angular/core").InputSignal<readonly HySelectOption<T>[]>;
+  /** Selected value. Two-way bindable and works with `[formField]`. */
+  readonly value: import("@angular/core").ModelSignal<T | undefined>;
+  /** Text shown while nothing is selected. */
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  /** Disables the select. Set automatically by Signal Forms. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Marks the field as required. Set automatically by Signal Forms. */
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Set by Signal Forms. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Set by Signal Forms. Only the first message is shown. */
+  readonly errors: import("@angular/core").InputSignal<readonly {
+    readonly kind: string;
+    readonly message?: string;
+  }[]>;
+  /** Set by Signal Forms. Errors show only after the field is touched. */
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Always render a native `<select>`. */
+  readonly native: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits when the control loses focus, so forms can mark it touched. */
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly labelable = true;
+  readonly id: import("@angular/core").Signal<string>;
+  readonly errorMessage: import("@angular/core").Signal<string | undefined>;
+  protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  /** Stays true while the panel fades out after `expanded` turns false. */
+  protected readonly rendered: import("@angular/core").WritableSignal<boolean>;
+  protected readonly positions: import("@angular/cdk/overlay").ConnectedPosition[];
+  protected readonly panelWidth: import("@angular/core").WritableSignal<number>;
+  protected readonly useNative: import("@angular/core").Signal<boolean>;
+  protected readonly selectedOption: import("@angular/core").Signal<HySelectOption<T> | undefined>;
+  protected readonly listValue: import("@angular/core").Signal<(T & ({} | null))[]>;
+  protected readonly showsError: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected setExpanded(open: boolean): void;
+  /** Runs when the overlay attaches a fresh panel. */
+  protected onAttach(): void;
+  private panelElement;
+  protected pick(values: readonly T[]): void;
+  /** Closes after a click on an option, including the one already selected. */
+  protected onPanelClick(event: MouseEvent): void;
+  protected close(): void;
+  protected pickNative(event: Event): void;
+  protected indexOf(value: T | undefined): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySelect<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySelect<any>, "hy-select", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "native": {
+      "alias": "native";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}