bank20baht-ui-angular 0.0.0-stage → 0.1.0

package/dist/elements.js

@@ -0,0 +1,4596 @@
+// Generated by scripts/generate.ts from bank20baht-ui's custom-elements.json. Do not edit:
+// change the element's JSDoc in packages/core and run `bun run generate`.
+import { booleanAttribute, Directive, Input, output } from '@angular/core';
+import { assign, hostElement, num, relay } from './runtime.js';
+import * as i0 from "@angular/core";
+/** `<baht-accordion>`: Accordion */
+export class BahtAccordionDirective {
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    set multiple(v) {
+        assign(this.element, 'multiple', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A section opened or closed. */
+        this.bahtToggle = output();
+        relay(this.element, 'baht-toggle', this.bahtToggle);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAccordionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtAccordionDirective, isStandalone: true, selector: "baht-accordion", inputs: { items: "items", multiple: ["multiple", "multiple", booleanAttribute] }, outputs: { bahtToggle: "bahtToggle" }, exportAs: ["bahtAccordion"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAccordionDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-accordion', exportAs: 'bahtAccordion' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtToggle: [{ type: i0.Output, args: ["bahtToggle"] }] } });
+/** `<baht-alert>`: Inline alert / callout */
+export class BahtAlertDirective {
+    set tone(v) {
+        assign(this.element, 'tone', v);
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set message(v) {
+        assign(this.element, 'message', v);
+    }
+    set dismissible(v) {
+        assign(this.element, 'dismissible', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The close button was pressed. */
+        this.bahtDismiss = output();
+        relay(this.element, 'baht-dismiss', this.bahtDismiss);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAlertDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtAlertDirective, isStandalone: true, selector: "baht-alert", inputs: { tone: "tone", heading: "heading", message: "message", dismissible: ["dismissible", "dismissible", booleanAttribute] }, outputs: { bahtDismiss: "bahtDismiss" }, exportAs: ["bahtAlert"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAlertDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-alert', exportAs: 'bahtAlert' }]
+        }], ctorParameters: () => [], propDecorators: { tone: [{
+                type: Input
+            }], heading: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], dismissible: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtDismiss: [{ type: i0.Output, args: ["bahtDismiss"] }] } });
+/** `<baht-app-shell>`: An application's frame: a header band, a navigator on the left and the page */
+export class BahtAppShellDirective {
+    set brand(v) {
+        assign(this.element, 'brand', v);
+    }
+    set brandSub(v) {
+        assign(this.element, 'brandSub', v);
+    }
+    set brandHref(v) {
+        assign(this.element, 'brandHref', v);
+    }
+    /** A further line in the header, naming the part of the application. */
+    set context(v) {
+        assign(this.element, 'context', v);
+    }
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    /** Key of the current entry. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Show a box that narrows the navigator as you type. */
+    set filterable(v) {
+        assign(this.element, 'filterable', v);
+    }
+    /** Accessible name of the navigator. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Groups folded away; the shell keeps it in step as headings are pressed. */
+    set collapsedGroups(v) {
+        assign(this.element, 'collapsedGroups', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** An entry was pressed. `detail: { key, href }`. Cancelable: `preventDefault()` to route yourself. Clicks with a modifier key are left to the browser. */
+        this.bahtNav = output();
+        /** A group heading was pressed. `detail: { group, collapsed }`. */
+        this.bahtNavGroup = output();
+        relay(this.element, 'baht-nav', this.bahtNav);
+        relay(this.element, 'baht-nav-group', this.bahtNavGroup);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAppShellDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtAppShellDirective, isStandalone: true, selector: "baht-app-shell", inputs: { brand: "brand", brandSub: "brandSub", brandHref: "brandHref", context: "context", items: "items", value: "value", filterable: ["filterable", "filterable", booleanAttribute], label: "label", collapsedGroups: "collapsedGroups" }, outputs: { bahtNav: "bahtNav", bahtNavGroup: "bahtNavGroup" }, exportAs: ["bahtAppShell"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAppShellDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-app-shell', exportAs: 'bahtAppShell' }]
+        }], ctorParameters: () => [], propDecorators: { brand: [{
+                type: Input
+            }], brandSub: [{
+                type: Input
+            }], brandHref: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], filterable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], collapsedGroups: [{
+                type: Input
+            }], bahtNav: [{ type: i0.Output, args: ["bahtNav"] }], bahtNavGroup: [{ type: i0.Output, args: ["bahtNavGroup"] }] } });
+/** `<baht-approval-chain>`: An approval route: each step in order, who it is with and how far it got */
+export class BahtApprovalChainDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set steps(v) {
+        assign(this.element, 'steps', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtApprovalChainDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtApprovalChainDirective, isStandalone: true, selector: "baht-approval-chain", inputs: { heading: "heading", steps: "steps" }, exportAs: ["bahtApprovalChain"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtApprovalChainDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-approval-chain', exportAs: 'bahtApprovalChain' }]
+        }], propDecorators: { heading: [{
+                type: Input
+            }], steps: [{
+                type: Input
+            }] } });
+/** `<baht-avatar>`: Small circular identity chip — initials derived from `label`, or an explicit `initials` override */
+export class BahtAvatarDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Full name; initials are derived from it when `initials` isn't set. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Explicit override — first 1-2 characters are shown as-is. */
+    set initials(v) {
+        assign(this.element, 'initials', v);
+    }
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAvatarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtAvatarDirective, isStandalone: true, selector: "baht-avatar", inputs: { label: "label", initials: "initials", size: "size" }, exportAs: ["bahtAvatar"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtAvatarDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-avatar', exportAs: 'bahtAvatar' }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], initials: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }] } });
+/** `<baht-badge>`: Status pill / tag / counter (20baht badges) */
+export class BahtBadgeDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set tone(v) {
+        assign(this.element, 'tone', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Force the dot on/off; defaults to on for status tones. */
+    set dot(v) {
+        assign(this.element, 'dot', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBadgeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtBadgeDirective, isStandalone: true, selector: "baht-badge", inputs: { tone: "tone", label: "label", dot: "dot" }, exportAs: ["bahtBadge"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBadgeDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-badge', exportAs: 'bahtBadge' }]
+        }], propDecorators: { tone: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], dot: [{
+                type: Input
+            }] } });
+/** `<baht-bar-chart>` */
+export class BahtBarChartDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Original API: `{ label, count }[]`, one bar each. */
+    set groups(v) {
+        assign(this.element, 'groups', v);
+    }
+    /** Series API: one entry per series, one value per category. */
+    set series(v) {
+        assign(this.element, 'series', v);
+    }
+    /** Category names, one per value index. */
+    set categories(v) {
+        assign(this.element, 'categories', v);
+    }
+    /** Bars across (default) or columns up. */
+    set orientation(v) {
+        assign(this.element, 'orientation', v);
+    }
+    /** Stack the series inside one band instead of grouping them side by side. */
+    set stacked(v) {
+        assign(this.element, 'stacked', v);
+    }
+    /** Previous-period values, drawn as a muted bar under each current bar. */
+    set compare(v) {
+        assign(this.element, 'compare', v);
+    }
+    /** Names the muted `compare` bar in the key and the table twin. */
+    set compareLabel(v) {
+        assign(this.element, 'compareLabel', v);
+    }
+    /** Budget / target lines drawn over the bars. */
+    set markers(v) {
+        assign(this.element, 'markers', v);
+    }
+    /** `ends` prints the value at the bar tip; `none` leaves it to the tooltip. */
+    set labelValues(v) {
+        assign(this.element, 'labelValues', v);
+    }
+    /** Index of the series (2+ series) or category (one series) to highlight. */
+    set emphasis(v) {
+        assign(this.element, 'emphasis', v);
+    }
+    /** Single color for every bar; per-series palette otherwise. */
+    set color(v) {
+        assign(this.element, 'color', v);
+    }
+    /** Accessible summary used by the vertical (graphics-only) rendering. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Shown instead of the marks when there is nothing to plot. */
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    /** Hold the previous render at reduced opacity while new data loads. */
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    /** Render the "View as table" twin under the chart. */
+    set showTable(v) {
+        assign(this.element, 'showTable', v);
+    }
+    /** How values are rendered in labels, ticks, tooltips and the table twin. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBarChartDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtBarChartDirective, isStandalone: true, selector: "baht-bar-chart", inputs: { groups: "groups", series: "series", categories: "categories", orientation: "orientation", stacked: ["stacked", "stacked", booleanAttribute], compare: "compare", compareLabel: "compareLabel", markers: "markers", labelValues: "labelValues", emphasis: "emphasis", color: "color", label: "label", emptyMessage: "emptyMessage", loading: ["loading", "loading", booleanAttribute], showTable: ["showTable", "showTable", booleanAttribute], format: "format", currency: "currency" }, exportAs: ["bahtBarChart"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBarChartDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-bar-chart', exportAs: 'bahtBarChart' }]
+        }], propDecorators: { groups: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], categories: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], stacked: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], compare: [{
+                type: Input
+            }], compareLabel: [{
+                type: Input
+            }], markers: [{
+                type: Input
+            }], labelValues: [{
+                type: Input
+            }], emphasis: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showTable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }] } });
+/** `<baht-breadcrumbs>`: Breadcrumb trail */
+export class BahtBreadcrumbsDirective {
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    set separator(v) {
+        assign(this.element, 'separator', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A crumb was pressed. */
+        this.bahtNavigate = output();
+        relay(this.element, 'baht-navigate', this.bahtNavigate);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBreadcrumbsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtBreadcrumbsDirective, isStandalone: true, selector: "baht-breadcrumbs", inputs: { items: "items", separator: "separator" }, outputs: { bahtNavigate: "bahtNavigate" }, exportAs: ["bahtBreadcrumbs"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtBreadcrumbsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-breadcrumbs', exportAs: 'bahtBreadcrumbs' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], separator: [{
+                type: Input
+            }], bahtNavigate: [{ type: i0.Output, args: ["bahtNavigate"] }] } });
+/** `<baht-button>`: Design-system button (20baht: no scale, no shadow change — color does the work) */
+export class BahtButtonDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** Forwarded to the native button — 'button' (default) or 'submit'. */
+    set type(v) {
+        assign(this.element, 'type', v);
+    }
+    /** Alternative to children for setting the label programmatically. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Optional leading icon from the curated set (copy/check/download/…). */
+    set icon(v) {
+        assign(this.element, 'icon', v);
+    }
+    /** Square icon-only button. Requires `label` for the accessible name. */
+    set iconOnly(v) {
+        assign(this.element, 'iconOnly', v);
+    }
+    /** A host `aria-label` never reaches assistive tech on its own — light DOM has no implicit ARIA relationship between a custom element and its rendered children, so an `aria-label` written on `<baht-button>` stays on the host and the inner native `<button>` keeps whatever text (or none) is inside it. Mirroring the attribute into this property forwards it to the inner button's `aria-label`, taking priority over `label`/icon-only fallback — this is how a glyph-only child (e.g. `‹`) gets a real accessible name without `icon-only`. Mapped to the plain `aria-label` attribute so hosts write it the way they naturally would; kept off the `ariaLabel` IDL accessor to avoid shadowing the platform's own ARIAMixin. */
+    set hostAriaLabel(v) {
+        assign(this.element, 'hostAriaLabel', v);
+    }
+    /** Keyboard shortcut that clicks this button from anywhere on the page, e.g. `alt+q`, `shift+alt+s`, `mod+enter` (`mod` = ⌘ on Mac, Ctrl elsewhere). Also shown in a hover/focus tooltip and announced through `aria-keyshortcuts`. */
+    set shortcut(v) {
+        assign(this.element, 'shortcut', v);
+    }
+    /** Where the shortcut tooltip sits. */
+    set tooltipPosition(v) {
+        assign(this.element, 'tooltipPosition', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtButtonDirective, isStandalone: true, selector: "baht-button", inputs: { variant: "variant", size: "size", disabled: ["disabled", "disabled", booleanAttribute], type: "type", label: "label", icon: "icon", iconOnly: ["iconOnly", "iconOnly", booleanAttribute], hostAriaLabel: "hostAriaLabel", shortcut: "shortcut", tooltipPosition: "tooltipPosition" }, exportAs: ["bahtButton"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtButtonDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-button', exportAs: 'bahtButton' }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], type: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], iconOnly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hostAriaLabel: [{
+                type: Input
+            }], shortcut: [{
+                type: Input
+            }], tooltipPosition: [{
+                type: Input
+            }] } });
+/** `<baht-card>`: Surface card (20baht: white on cream, 1px border, no shadow at rest — the border carries the separation) */
+export class BahtCardDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set subtitle(v) {
+        assign(this.element, 'subtitle', v);
+    }
+    /** hero = 20px radius + roomier padding (large/feature cards). */
+    set hero(v) {
+        assign(this.element, 'hero', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtCardDirective, isStandalone: true, selector: "baht-card", inputs: { heading: "heading", subtitle: "subtitle", hero: ["hero", "hero", booleanAttribute] }, exportAs: ["bahtCard"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCardDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-card', exportAs: 'bahtCard' }]
+        }], propDecorators: { heading: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], hero: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+/** `<baht-catalog-card>`: A card that opens something: picture, name, one line about it */
+export class BahtCatalogCardDirective {
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set description(v) {
+        assign(this.element, 'description', v);
+    }
+    set image(v) {
+        assign(this.element, 'image', v);
+    }
+    set href(v) {
+        assign(this.element, 'href', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The link was pressed. `detail: { href }`. Cancelable: `preventDefault()` to route yourself. */
+        this.bahtOpen = output();
+        relay(this.element, 'baht-open', this.bahtOpen);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCatalogCardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtCatalogCardDirective, isStandalone: true, selector: "baht-catalog-card", inputs: { heading: "heading", description: "description", image: "image", href: "href" }, outputs: { bahtOpen: "bahtOpen" }, exportAs: ["bahtCatalogCard"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCatalogCardDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-catalog-card', exportAs: 'bahtCatalogCard' }]
+        }], ctorParameters: () => [], propDecorators: { heading: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], image: [{
+                type: Input
+            }], href: [{
+                type: Input
+            }], bahtOpen: [{ type: i0.Output, args: ["bahtOpen"] }] } });
+/** `<baht-checkbox>` */
+export class BahtCheckboxDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCheckboxDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtCheckboxDirective, isStandalone: true, selector: "baht-checkbox", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtCheckbox"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCheckboxDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-checkbox', exportAs: 'bahtCheckbox' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-code>`: Monospace code (20baht): an inline chip or a block */
+export class BahtCodeDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    /** Alternative to children for setting the code text programmatically. */
+    set code(v) {
+        assign(this.element, 'code', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCodeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtCodeDirective, isStandalone: true, selector: "baht-code", inputs: { variant: "variant", code: "code" }, exportAs: ["bahtCode"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCodeDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-code', exportAs: 'bahtCode' }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], code: [{
+                type: Input
+            }] } });
+/** `<baht-column-picker>`: The Available / Selected dialog behind a table's Columns button: add, remove and reorder columns, and expand a reference column to dot-walk into its fields. */
+export class BahtColumnPickerDirective {
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    set columns(v) {
+        assign(this.element, 'columns', v);
+    }
+    /** The columns showing now, in order. */
+    set selected(v) {
+        assign(this.element, 'selected', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** OK was pressed. `detail: ColumnsChangeDetail`. */
+        this.bahtColumnsChange = output();
+        /** The dialog was dismissed, or OK was pressed. */
+        this.bahtClose = output();
+        relay(this.element, 'baht-columns-change', this.bahtColumnsChange);
+        relay(this.element, 'baht-close', this.bahtClose);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtColumnPickerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtColumnPickerDirective, isStandalone: true, selector: "baht-column-picker", inputs: { open: ["open", "open", booleanAttribute], columns: "columns", selected: "selected" }, outputs: { bahtColumnsChange: "bahtColumnsChange", bahtClose: "bahtClose" }, exportAs: ["bahtColumnPicker"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtColumnPickerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-column-picker', exportAs: 'bahtColumnPicker' }]
+        }], ctorParameters: () => [], propDecorators: { open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], columns: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], bahtColumnsChange: [{ type: i0.Output, args: ["bahtColumnsChange"] }], bahtClose: [{ type: i0.Output, args: ["bahtClose"] }] } });
+/** `<baht-comments>`: A conversation on a record: the thread, oldest first, and a composer */
+export class BahtCommentsDirective {
+    set entries(v) {
+        assign(this.element, 'entries', v);
+    }
+    set allowInternal(v) {
+        assign(this.element, 'allowInternal', v);
+    }
+    set placeholder(v) {
+        assign(this.element, 'placeholder', v);
+    }
+    set internalLabel(v) {
+        assign(this.element, 'internalLabel', v);
+    }
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    set busy(v) {
+        assign(this.element, 'busy', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The composer was submitted; the box clears. */
+        this.bahtSubmit = output();
+        relay(this.element, 'baht-submit', this.bahtSubmit);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCommentsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtCommentsDirective, isStandalone: true, selector: "baht-comments", inputs: { entries: "entries", allowInternal: ["allowInternal", "allowInternal", booleanAttribute], placeholder: "placeholder", internalLabel: "internalLabel", emptyMessage: "emptyMessage", busy: ["busy", "busy", booleanAttribute] }, outputs: { bahtSubmit: "bahtSubmit" }, exportAs: ["bahtComments"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCommentsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-comments', exportAs: 'bahtComments' }]
+        }], ctorParameters: () => [], propDecorators: { entries: [{
+                type: Input
+            }], allowInternal: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], placeholder: [{
+                type: Input
+            }], internalLabel: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], busy: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtSubmit: [{ type: i0.Output, args: ["bahtSubmit"] }] } });
+/** `<baht-currency>`: Money input: plain digits while typing, thousands-separated on blur */
+export class BahtCurrencyDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCurrencyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtCurrencyDirective, isStandalone: true, selector: "baht-currency", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtCurrency"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtCurrencyDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-currency', exportAs: 'bahtCurrency' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-datepicker>`: Calendar field on top of flatpickr */
+export class BahtDatepickerDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtDatepickerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtDatepickerDirective, isStandalone: true, selector: "baht-datepicker", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtDatepicker"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtDatepickerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-datepicker', exportAs: 'bahtDatepicker' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-donut-chart>`: Pure-SVG donut with a legend that carries value and share */
+export class BahtDonutChartDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set groups(v) {
+        assign(this.element, 'groups', v);
+    }
+    set total(v) {
+        assign(this.element, 'total', v);
+    }
+    /** Single-series color override (first segment). */
+    set color(v) {
+        assign(this.element, 'color', v);
+    }
+    set centerLabel(v) {
+        assign(this.element, 'centerLabel', v);
+    }
+    /** Label of the folded tail bucket. */
+    set otherLabel(v) {
+        assign(this.element, 'otherLabel', v);
+    }
+    /** Shown instead of the marks when there is nothing to plot. */
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    /** Hold the previous render at reduced opacity while new data loads. */
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    /** Render the "View as table" twin under the chart. */
+    set showTable(v) {
+        assign(this.element, 'showTable', v);
+    }
+    /** How values are rendered in labels, ticks, tooltips and the table twin. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtDonutChartDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtDonutChartDirective, isStandalone: true, selector: "baht-donut-chart", inputs: { groups: "groups", total: "total", color: "color", centerLabel: "centerLabel", otherLabel: "otherLabel", emptyMessage: "emptyMessage", loading: ["loading", "loading", booleanAttribute], showTable: ["showTable", "showTable", booleanAttribute], format: "format", currency: "currency" }, exportAs: ["bahtDonutChart"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtDonutChartDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-donut-chart', exportAs: 'bahtDonutChart' }]
+        }], propDecorators: { groups: [{
+                type: Input
+            }], total: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], centerLabel: [{
+                type: Input
+            }], otherLabel: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showTable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }] } });
+/** `<baht-edit-table>`: A table whose cells are edited in place (reference lists, catalog items, groups) */
+export class BahtEditTableDirective {
+    set columns(v) {
+        assign(this.element, 'columns', v);
+    }
+    set rows(v) {
+        assign(this.element, 'rows', v);
+    }
+    set rowKey(v) {
+        assign(this.element, 'rowKey', v);
+    }
+    set addable(v) {
+        assign(this.element, 'addable', v);
+    }
+    set removable(v) {
+        assign(this.element, 'removable', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The blank first row was added (`addable`). */
+        this.bahtRowAdd = output();
+        /** A changed row's Save was pressed. */
+        this.bahtRowSave = output();
+        /** Remove was pressed (`removable`). */
+        this.bahtRowDelete = output();
+        relay(this.element, 'baht-row-add', this.bahtRowAdd);
+        relay(this.element, 'baht-row-save', this.bahtRowSave);
+        relay(this.element, 'baht-row-delete', this.bahtRowDelete);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtEditTableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtEditTableDirective, isStandalone: true, selector: "baht-edit-table", inputs: { columns: "columns", rows: "rows", rowKey: "rowKey", addable: ["addable", "addable", booleanAttribute], removable: ["removable", "removable", booleanAttribute], label: "label" }, outputs: { bahtRowAdd: "bahtRowAdd", bahtRowSave: "bahtRowSave", bahtRowDelete: "bahtRowDelete" }, exportAs: ["bahtEditTable"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtEditTableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-edit-table', exportAs: 'bahtEditTable' }]
+        }], ctorParameters: () => [], propDecorators: { columns: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], rowKey: [{
+                type: Input
+            }], addable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], removable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], bahtRowAdd: [{ type: i0.Output, args: ["bahtRowAdd"] }], bahtRowSave: [{ type: i0.Output, args: ["bahtRowSave"] }], bahtRowDelete: [{ type: i0.Output, args: ["bahtRowDelete"] }] } });
+/** `<baht-empty-state>`: Centered "nothing here" placeholder for lists, tables, and searches */
+export class BahtEmptyStateDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Illustration name (`empty-box`, `search-slash`, `folder`, …), or any emoji / short text. Empty string hides it. */
+    set icon(v) {
+        assign(this.element, 'icon', v);
+    }
+    set message(v) {
+        assign(this.element, 'message', v);
+    }
+    set hint(v) {
+        assign(this.element, 'hint', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtEmptyStateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtEmptyStateDirective, isStandalone: true, selector: "baht-empty-state", inputs: { icon: "icon", message: "message", hint: "hint" }, exportAs: ["bahtEmptyState"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtEmptyStateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-empty-state', exportAs: 'bahtEmptyState' }]
+        }], propDecorators: { icon: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }] } });
+/** `<baht-error-state>`: Centered failure placeholder with an optional retry action */
+export class BahtErrorStateDirective {
+    /** Illustration name (`error` by default), or any emoji / short text. Empty string hides it. */
+    set icon(v) {
+        assign(this.element, 'icon', v);
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set message(v) {
+        assign(this.element, 'message', v);
+    }
+    /** Renders a retry button with this label; omit for no action. */
+    set retryLabel(v) {
+        assign(this.element, 'retryLabel', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Retry was pressed. */
+        this.bahtRetry = output();
+        relay(this.element, 'baht-retry', this.bahtRetry);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtErrorStateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtErrorStateDirective, isStandalone: true, selector: "baht-error-state", inputs: { icon: "icon", heading: "heading", message: "message", retryLabel: "retryLabel" }, outputs: { bahtRetry: "bahtRetry" }, exportAs: ["bahtErrorState"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtErrorStateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-error-state', exportAs: 'bahtErrorState' }]
+        }], ctorParameters: () => [], propDecorators: { icon: [{
+                type: Input
+            }], heading: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], retryLabel: [{
+                type: Input
+            }], bahtRetry: [{ type: i0.Output, args: ["bahtRetry"] }] } });
+/** `<baht-fieldset>`: Semantic group wrapper (native <fieldset>/<legend>) */
+export class BahtFieldsetDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set legend(v) {
+        assign(this.element, 'legend', v);
+    }
+    /** Muted help line under the group (e.g. "Fill both languages for accurate reading"). */
+    set help(v) {
+        assign(this.element, 'help', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFieldsetDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtFieldsetDirective, isStandalone: true, selector: "baht-fieldset", inputs: { legend: "legend", help: "help", disabled: ["disabled", "disabled", booleanAttribute] }, exportAs: ["bahtFieldset"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFieldsetDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-fieldset', exportAs: 'bahtFieldset' }]
+        }], propDecorators: { legend: [{
+                type: Input
+            }], help: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+/** `<baht-file>`: File field (spec 01 §2 + §13) */
+export class BahtFileDirective {
+    /** Resolved registry uploader — <baht-form> injects it when `field.uploader` is set. */
+    set uploader(v) {
+        assign(this.element, 'uploader', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFileDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtFileDirective, isStandalone: true, selector: "baht-file", inputs: { uploader: "uploader", field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtFile"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFileDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-file', exportAs: 'bahtFile' }]
+        }], ctorParameters: () => [], propDecorators: { uploader: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-filter>`: Filter chip group */
+export class BahtFilterDirective {
+    set options(v) {
+        assign(this.element, 'options', v);
+    }
+    set selected(v) {
+        assign(this.element, 'selected', v);
+    }
+    /** Look: `'chips'` (default) = separate pill chips; `'segmented'` = one joined segmented control. With `multiple=false` a segmented control never clears. */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    /** false = radio behavior (max one active; clicking it again clears — except with `variant="segmented"`, where the active segment stays selected). */
+    set multiple(v) {
+        assign(this.element, 'multiple', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** Accessible name for the chip group. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The selection changed. */
+        this.bahtChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFilterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtFilterDirective, isStandalone: true, selector: "baht-filter", inputs: { options: "options", selected: "selected", variant: "variant", multiple: ["multiple", "multiple", booleanAttribute], disabled: ["disabled", "disabled", booleanAttribute], label: "label" }, outputs: { bahtChange: "bahtChange" }, exportAs: ["bahtFilter"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFilterDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-filter', exportAs: 'bahtFilter' }]
+        }], ctorParameters: () => [], propDecorators: { options: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }] } });
+/** `<baht-filter-builder>`: Builds a filter for a list: rows of column, comparison and value, all or any of them */
+export class BahtFilterBuilderDirective {
+    set fields(v) {
+        assign(this.element, 'fields', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The filter changed. `detail: { value }`. */
+        this.bahtChange = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFilterBuilderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtFilterBuilderDirective, isStandalone: true, selector: "baht-filter-builder", inputs: { fields: "fields", value: "value" }, outputs: { bahtChange: "bahtChange", valueChange: "valueChange" }, exportAs: ["bahtFilterBuilder"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFilterBuilderDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-filter-builder', exportAs: 'bahtFilterBuilder' }]
+        }], ctorParameters: () => [], propDecorators: { fields: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-form>`: <baht-form> — dumb controlled form renderer (spec 01) */
+export class BahtFormDirective {
+    set form(v) {
+        assign(this.element, 'form', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set registry(v) {
+        assign(this.element, 'registry', v);
+    }
+    /** Label every non-required field "(optional)" (localized) instead of relying on asterisks alone. */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set options(v) {
+        assign(this.element, 'options', v);
+    }
+    /** L2 (workflow) derived per-field UI state, keyed by field key. Optional. */
+    set fieldStates(v) {
+        assign(this.element, 'fieldStates', v);
+    }
+    /** Name of a view from `form.views`. Display-only: when set, only that view's fields are rendered and validated (the user can only fix what they see), but getData() still returns the FULL form — the server always validates the complete schema, views never change the submit payload. */
+    set view(v) {
+        assign(this.element, 'view', v);
+    }
+    /** Feature-flag values (spec 01 §12) — fields whose `flag` is off behave as if they were never in the schema: no render, no validation, no payload. */
+    set flags(v) {
+        assign(this.element, 'flags', v);
+    }
+    /** Key of the open tab section; the first one showing when unset or gone. */
+    set tab(v) {
+        assign(this.element, 'tab', v);
+    }
+    /** Force every field readonly — a display-only render of this form's own layout/widths. */
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A tab of a tabbed layout was picked. */
+        this.bahtTabChange = output();
+        /** `validate()` ran. */
+        this.bahtValidity = output();
+        /** A field changed (an edit or a script); `data` is the whole form. */
+        this.bahtChange = output();
+        relay(this.element, 'baht-tab-change', this.bahtTabChange);
+        relay(this.element, 'baht-validity', this.bahtValidity);
+        relay(this.element, 'baht-change', this.bahtChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFormDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtFormDirective, isStandalone: true, selector: "baht-form", inputs: { form: "form", value: "value", registry: "registry", showOptional: ["showOptional", "showOptional", booleanAttribute], options: "options", fieldStates: "fieldStates", view: "view", flags: "flags", tab: "tab", readonly: ["readonly", "readonly", booleanAttribute] }, outputs: { bahtTabChange: "bahtTabChange", bahtValidity: "bahtValidity", bahtChange: "bahtChange" }, exportAs: ["bahtForm"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtFormDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-form', exportAs: 'bahtForm' }]
+        }], ctorParameters: () => [], propDecorators: { form: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], registry: [{
+                type: Input
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], options: [{
+                type: Input
+            }], fieldStates: [{
+                type: Input
+            }], view: [{
+                type: Input
+            }], flags: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtTabChange: [{ type: i0.Output, args: ["bahtTabChange"] }], bahtValidity: [{ type: i0.Output, args: ["bahtValidity"] }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }] } });
+/** `<baht-heatmap>`: Calendar heat for one month or N weeks: one cell per day, colored on the sequential ramp, with a weekday header, a per-cell tooltip and a "less / more" scale legend */
+export class BahtHeatmapDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** `{ date: 'YYYY-MM-DD', value }[]`; days with no entry render as empty. */
+    set values(v) {
+        assign(this.element, 'values', v);
+    }
+    /** First day (inclusive), `YYYY-MM-DD`. Defaults to the earliest value. */
+    set from(v) {
+        assign(this.element, 'from', v);
+    }
+    /** Last day (inclusive), `YYYY-MM-DD`. Defaults to the latest value. */
+    set to(v) {
+        assign(this.element, 'to', v);
+    }
+    /** Caption on the low end of the scale legend. */
+    set lessLabel(v) {
+        assign(this.element, 'lessLabel', v);
+    }
+    /** Caption on the high end of the scale legend. */
+    set moreLabel(v) {
+        assign(this.element, 'moreLabel', v);
+    }
+    /** Text shown in a zero/empty cell in `show-values` mode. */
+    set zeroLabel(v) {
+        assign(this.element, 'zeroLabel', v);
+    }
+    /** Roomier month-grid layout with the day number and value printed in each cell. */
+    set showValues(v) {
+        assign(this.element, 'showValues', v);
+    }
+    /** Accessible summary; falls back to a generated sentence. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Shown instead of the marks when there is nothing to plot. */
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    /** Hold the previous render at reduced opacity while new data loads. */
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    /** Render the "View as table" twin under the chart. */
+    set showTable(v) {
+        assign(this.element, 'showTable', v);
+    }
+    /** How values are rendered in labels, ticks, tooltips and the table twin. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtHeatmapDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtHeatmapDirective, isStandalone: true, selector: "baht-heatmap", inputs: { values: "values", from: "from", to: "to", lessLabel: "lessLabel", moreLabel: "moreLabel", zeroLabel: "zeroLabel", showValues: ["showValues", "showValues", booleanAttribute], label: "label", emptyMessage: "emptyMessage", loading: ["loading", "loading", booleanAttribute], showTable: ["showTable", "showTable", booleanAttribute], format: "format", currency: "currency" }, exportAs: ["bahtHeatmap"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtHeatmapDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-heatmap', exportAs: 'bahtHeatmap' }]
+        }], propDecorators: { values: [{
+                type: Input
+            }], from: [{
+                type: Input
+            }], to: [{
+                type: Input
+            }], lessLabel: [{
+                type: Input
+            }], moreLabel: [{
+                type: Input
+            }], zeroLabel: [{
+                type: Input
+            }], showValues: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showTable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }] } });
+/** `<baht-input>`: text + email + password share one control; email differs only in input type + validator, password only in input type (masked, never formatted or logged). */
+export class BahtInputDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtInputDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtInputDirective, isStandalone: true, selector: "baht-input", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtInput"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtInputDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-input', exportAs: 'bahtInput' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-keyvalue-editor>`: Inline key = value row editor (field maps, config objects, …) */
+export class BahtKeyvalueEditorDirective {
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set keyPlaceholder(v) {
+        assign(this.element, 'keyPlaceholder', v);
+    }
+    set valuePlaceholder(v) {
+        assign(this.element, 'valuePlaceholder', v);
+    }
+    set add_label(v) {
+        assign(this.element, 'add_label', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A pair was added, edited or removed. */
+        this.bahtChange = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtKeyvalueEditorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtKeyvalueEditorDirective, isStandalone: true, selector: "baht-keyvalue-editor", inputs: { value: "value", keyPlaceholder: "keyPlaceholder", valuePlaceholder: "valuePlaceholder", add_label: "add_label", disabled: ["disabled", "disabled", booleanAttribute] }, outputs: { bahtChange: "bahtChange", valueChange: "valueChange" }, exportAs: ["bahtKeyvalueEditor"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtKeyvalueEditorDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-keyvalue-editor', exportAs: 'bahtKeyvalueEditor' }]
+        }], ctorParameters: () => [], propDecorators: { value: [{
+                type: Input
+            }], keyPlaceholder: [{
+                type: Input
+            }], valuePlaceholder: [{
+                type: Input
+            }], add_label: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-line-chart>`: Multi-series line chart with a crosshair tooltip that lists every series at the hovered x */
+export class BahtLineChartDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** One entry per line: `{ name, values, color? }`. */
+    set series(v) {
+        assign(this.element, 'series', v);
+    }
+    /** X labels, one per value index. */
+    set categories(v) {
+        assign(this.element, 'categories', v);
+    }
+    /** Fill under the line at 10% opacity. Single series only. */
+    set area(v) {
+        assign(this.element, 'area', v);
+    }
+    /** Reference lines (targets, averages) drawn across the plot. */
+    set markers(v) {
+        assign(this.element, 'markers', v);
+    }
+    /** Draw the last N points dashed — a projection, not measured data. */
+    set forecast(v) {
+        assign(this.element, 'forecast', v);
+    }
+    /** Hairline at this value (0, a target). `null` draws none. */
+    set baseline(v) {
+        assign(this.element, 'baseline', v);
+    }
+    /** `ends` labels the last point of each line when the labels do not collide. */
+    set labelValues(v) {
+        assign(this.element, 'labelValues', v);
+    }
+    /** Accessible summary; falls back to a generated sentence. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Shown instead of the marks when there is nothing to plot. */
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    /** Hold the previous render at reduced opacity while new data loads. */
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    /** Render the "View as table" twin under the chart. */
+    set showTable(v) {
+        assign(this.element, 'showTable', v);
+    }
+    /** How values are rendered in labels, ticks, tooltips and the table twin. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLineChartDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtLineChartDirective, isStandalone: true, selector: "baht-line-chart", inputs: { series: "series", categories: "categories", area: ["area", "area", booleanAttribute], markers: "markers", forecast: ["forecast", "forecast", num], baseline: "baseline", labelValues: "labelValues", label: "label", emptyMessage: "emptyMessage", loading: ["loading", "loading", booleanAttribute], showTable: ["showTable", "showTable", booleanAttribute], format: "format", currency: "currency" }, exportAs: ["bahtLineChart"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLineChartDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-line-chart', exportAs: 'bahtLineChart' }]
+        }], propDecorators: { series: [{
+                type: Input
+            }], categories: [{
+                type: Input
+            }], area: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], markers: [{
+                type: Input
+            }], forecast: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], baseline: [{
+                type: Input
+            }], labelValues: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showTable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }] } });
+/** `<baht-link>`: Styled anchor (20baht underline treatment) */
+export class BahtLinkDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set href(v) {
+        assign(this.element, 'href', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    set external(v) {
+        assign(this.element, 'external', v);
+    }
+    /** Screen-reader suffix for external links (override to localize). */
+    set externalHint(v) {
+        assign(this.element, 'externalHint', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtLinkDirective, isStandalone: true, selector: "baht-link", inputs: { href: "href", label: "label", external: ["external", "external", booleanAttribute], externalHint: "externalHint" }, exportAs: ["bahtLink"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLinkDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-link', exportAs: 'bahtLink' }]
+        }], propDecorators: { href: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], external: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], externalHint: [{
+                type: Input
+            }] } });
+/** `<baht-list>`: Display list — same server-side contract as <baht-table>: `items` is the current page, `loading` shows skeleton rows, the host fetches on `baht-page-change` (pair with <baht-pagination>). */
+export class BahtListDirective {
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    set errorMessage(v) {
+        assign(this.element, 'errorMessage', v);
+    }
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    set skeletonRows(v) {
+        assign(this.element, 'skeletonRows', v);
+    }
+    set clickable(v) {
+        assign(this.element, 'clickable', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** An item was pressed. */
+        this.bahtItemClick = output();
+        relay(this.element, 'baht-item-click', this.bahtItemClick);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtListDirective, isStandalone: true, selector: "baht-list", inputs: { items: "items", loading: ["loading", "loading", booleanAttribute], error: ["error", "error", booleanAttribute], errorMessage: "errorMessage", emptyMessage: "emptyMessage", skeletonRows: ["skeletonRows", "skeletonRows", num], clickable: ["clickable", "clickable", booleanAttribute] }, outputs: { bahtItemClick: "bahtItemClick" }, exportAs: ["bahtList"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtListDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-list', exportAs: 'bahtList' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], errorMessage: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], skeletonRows: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], clickable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtItemClick: [{ type: i0.Output, args: ["bahtItemClick"] }] } });
+/** `<baht-loading-overlay>`: Full-viewport loading scrim with a centered spinner (0.4 ink scrim, same as `<baht-modal>`'s) */
+export class BahtLoadingOverlayDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLoadingOverlayDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtLoadingOverlayDirective, isStandalone: true, selector: "baht-loading-overlay", inputs: { open: ["open", "open", booleanAttribute], label: "label" }, exportAs: ["bahtLoadingOverlay"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtLoadingOverlayDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-loading-overlay', exportAs: 'bahtLoadingOverlay' }]
+        }], propDecorators: { open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }] } });
+/** `<baht-markdown>`: `type: 'markdown'` — GitHub's comment box: Write and Preview tabs over a plain string of markdown */
+export class BahtMarkdownDirective {
+    /** Resolved registry uploader — <baht-form> injects it when `field.uploader` is set. */
+    set uploader(v) {
+        assign(this.element, 'uploader', v);
+    }
+    /** Which image URLs may embed — <baht-form> injects `registry.markdownImage`. */
+    set allowImage(v) {
+        assign(this.element, 'allowImage', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMarkdownDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtMarkdownDirective, isStandalone: true, selector: "baht-markdown", inputs: { uploader: "uploader", allowImage: "allowImage", field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtMarkdown"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMarkdownDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-markdown', exportAs: 'bahtMarkdown' }]
+        }], ctorParameters: () => [], propDecorators: { uploader: [{
+                type: Input
+            }], allowImage: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-markdown-view>`: markdown source as sanitized HTML: GitHub-flavoured, raw HTML shown as text, and images only where `allowImage` says (same origin by default) */
+export class BahtMarkdownViewDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** The markdown source. */
+    set source(v) {
+        assign(this.element, 'source', v);
+    }
+    /** Which image URLs may embed; any other image renders as a link. */
+    set allowImage(v) {
+        assign(this.element, 'allowImage', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMarkdownViewDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtMarkdownViewDirective, isStandalone: true, selector: "baht-markdown-view", inputs: { source: "source", allowImage: "allowImage" }, exportAs: ["bahtMarkdownView"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMarkdownViewDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-markdown-view', exportAs: 'bahtMarkdownView' }]
+        }], propDecorators: { source: [{
+                type: Input
+            }], allowImage: [{
+                type: Input
+            }] } });
+/** `<baht-menu>`: Action menu behind a button: the ⋯ "more" menu on a table row or card, or a labelled "Export ▾" menu */
+export class BahtMenuDirective {
+    /** Menu entries. Set as a property: `el.items = [...]`. */
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    /** Visible trigger text; empty = an icon-only trigger. */
+    set triggerLabel(v) {
+        assign(this.element, 'triggerLabel', v);
+    }
+    /** Trigger icon from the curated set (default `more`, the ⋯). Ignored when `trigger-label` is set. */
+    set icon(v) {
+        assign(this.element, 'icon', v);
+    }
+    /** Accessible name of the trigger (and the menu). Defaults to the trigger text, else "More actions". */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Trigger look: `ghost` (default) or `secondary`. */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    /** Menu edge aligned with the trigger: `'end'` (default) or `'start'`. */
+    set align(v) {
+        assign(this.element, 'align', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** Non-item first line of the menu ("Signed in as …"). */
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** An item was picked (click, keyboard or its shortcut). `detail: { value, item }`. */
+        this.bahtSelect = output();
+        relay(this.element, 'baht-select', this.bahtSelect);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMenuDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtMenuDirective, isStandalone: true, selector: "baht-menu", inputs: { items: "items", triggerLabel: "triggerLabel", icon: "icon", label: "label", variant: "variant", size: "size", align: "align", disabled: ["disabled", "disabled", booleanAttribute], heading: "heading" }, outputs: { bahtSelect: "bahtSelect" }, exportAs: ["bahtMenu"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMenuDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-menu', exportAs: 'bahtMenu' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], triggerLabel: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], heading: [{
+                type: Input
+            }], bahtSelect: [{ type: i0.Output, args: ["bahtSelect"] }] } });
+/** `<baht-meter>`: Spent-against-budget meter */
+export class BahtMeterDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Amount used so far. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** The budget / capacity the value is measured against. */
+    set max(v) {
+        assign(this.element, 'max', v);
+    }
+    /** Sentence-case caption. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** How value and max read: number | currency | percent | compact. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    /** Fractions of `max` where the fill turns warning / danger. */
+    set thresholds(v) {
+        assign(this.element, 'thresholds', v);
+    }
+    /** Pace marker: where the value *should* be by now. `null` hides the tick. */
+    set expected(v) {
+        assign(this.element, 'expected', v);
+    }
+    /** Word shown after the numbers when the meter is over budget. */
+    set overLabel(v) {
+        assign(this.element, 'overLabel', v);
+    }
+    /** Word shown when the value has reached the budget exactly, but not passed it. */
+    set atLabel(v) {
+        assign(this.element, 'atLabel', v);
+    }
+    /** Word shown after the numbers when the meter is near its limit. */
+    set nearLabel(v) {
+        assign(this.element, 'nearLabel', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMeterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtMeterDirective, isStandalone: true, selector: "baht-meter", inputs: { value: ["value", "value", num], max: ["max", "max", num], label: "label", format: "format", currency: "currency", thresholds: "thresholds", expected: "expected", overLabel: "overLabel", atLabel: "atLabel", nearLabel: "nearLabel" }, exportAs: ["bahtMeter"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMeterDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-meter', exportAs: 'bahtMeter' }]
+        }], propDecorators: { value: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], max: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], label: [{
+                type: Input
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }], thresholds: [{
+                type: Input
+            }], expected: [{
+                type: Input
+            }], overLabel: [{
+                type: Input
+            }], atLabel: [{
+                type: Input
+            }], nearLabel: [{
+                type: Input
+            }] } });
+/** `<baht-modal>`: Modal dialog (20baht: 0.4 ink scrim, no blur; float shadow; 20px radius) */
+export class BahtModalDirective {
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    /** One muted line under the heading; also becomes the dialog's aria-describedby. */
+    set description(v) {
+        assign(this.element, 'description', v);
+    }
+    set showClose(v) {
+        assign(this.element, 'showClose', v);
+    }
+    /** `'center'` (default) dialog, `'sheet'` bottom sheet below 600px (centered from 600px up), or `'side'` full-height drawer at the inline end. */
+    set placement(v) {
+        assign(this.element, 'placement', v);
+    }
+    /** Scrim click requests close. Off by default: a stray click outside the panel must not throw away what the user typed — close via ×, Escape or your buttons. */
+    set closeOnScrim(v) {
+        assign(this.element, 'closeOnScrim', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Asked to close; the host sets `open` to false. */
+        this.bahtClose = output();
+        relay(this.element, 'baht-close', this.bahtClose);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtModalDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtModalDirective, isStandalone: true, selector: "baht-modal", inputs: { open: ["open", "open", booleanAttribute], heading: "heading", description: "description", showClose: ["showClose", "showClose", booleanAttribute], placement: "placement", closeOnScrim: ["closeOnScrim", "closeOnScrim", booleanAttribute] }, outputs: { bahtClose: "bahtClose" }, exportAs: ["bahtModal"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtModalDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-modal', exportAs: 'bahtModal' }]
+        }], ctorParameters: () => [], propDecorators: { open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], heading: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], showClose: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], placement: [{
+                type: Input
+            }], closeOnScrim: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtClose: [{ type: i0.Output, args: ["bahtClose"] }] } });
+/** `<baht-multiselect>`: Multi-pick rendered as a checkbox group; value = array of option keys. */
+export class BahtMultiselectDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMultiselectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtMultiselectDirective, isStandalone: true, selector: "baht-multiselect", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtMultiselect"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtMultiselectDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-multiselect', exportAs: 'bahtMultiselect' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-notification-bell>`: Header bell: an icon button with the unread count and a panel listing the notifications */
+export class BahtNotificationBellDirective {
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    /** Unread count on the badge; defaults to the unread items. */
+    set count(v) {
+        assign(this.element, 'count', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The panel opened (refresh the items then). */
+        this.bahtOpen = output();
+        /** A notification was picked; the panel closes. */
+        this.bahtSelect = output();
+        /** "Mark all read" was pressed. */
+        this.bahtMarkAll = output();
+        relay(this.element, 'baht-open', this.bahtOpen);
+        relay(this.element, 'baht-select', this.bahtSelect);
+        relay(this.element, 'baht-mark-all', this.bahtMarkAll);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtNotificationBellDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtNotificationBellDirective, isStandalone: true, selector: "baht-notification-bell", inputs: { items: "items", count: "count", label: "label", emptyMessage: "emptyMessage" }, outputs: { bahtOpen: "bahtOpen", bahtSelect: "bahtSelect", bahtMarkAll: "bahtMarkAll" }, exportAs: ["bahtNotificationBell"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtNotificationBellDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-notification-bell', exportAs: 'bahtNotificationBell' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], count: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], bahtOpen: [{ type: i0.Output, args: ["bahtOpen"] }], bahtSelect: [{ type: i0.Output, args: ["bahtSelect"] }], bahtMarkAll: [{ type: i0.Output, args: ["bahtMarkAll"] }] } });
+/** `<baht-number>` */
+export class BahtNumberDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtNumberDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtNumberDirective, isStandalone: true, selector: "baht-number", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtNumber"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtNumberDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-number', exportAs: 'bahtNumber' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-order-box>`: The box beside a catalog item that orders it */
+export class BahtOrderBoxDirective {
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    /** The button's text. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The button was pressed. */
+        this.bahtOrder = output();
+        relay(this.element, 'baht-order', this.bahtOrder);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtOrderBoxDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtOrderBoxDirective, isStandalone: true, selector: "baht-order-box", inputs: { heading: "heading", label: "label", disabled: ["disabled", "disabled", booleanAttribute] }, outputs: { bahtOrder: "bahtOrder" }, exportAs: ["bahtOrderBox"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtOrderBoxDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-order-box', exportAs: 'bahtOrderBox' }]
+        }], ctorParameters: () => [], propDecorators: { heading: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtOrder: [{ type: i0.Output, args: ["bahtOrder"] }] } });
+/** `<baht-otp>`: One-time-code input: N boxes, auto-advance, backspace steps back, paste distributes */
+export class BahtOtpDirective {
+    set length(v) {
+        assign(this.element, 'length', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** 'numeric' restricts to digits; 'text' allows anything. */
+    set mode(v) {
+        assign(this.element, 'mode', v);
+    }
+    /** Accessible name for the group of boxes. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A digit changed. */
+        this.bahtChange = output();
+        /** Every box is filled. */
+        this.bahtOtpComplete = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-otp-complete', this.bahtOtpComplete);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+        relay(this.element, 'baht-otp-complete', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtOtpDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtOtpDirective, isStandalone: true, selector: "baht-otp", inputs: { length: ["length", "length", num], value: "value", disabled: ["disabled", "disabled", booleanAttribute], mode: "mode", label: "label" }, outputs: { bahtChange: "bahtChange", bahtOtpComplete: "bahtOtpComplete", valueChange: "valueChange" }, exportAs: ["bahtOtp"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtOtpDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-otp', exportAs: 'bahtOtp' }]
+        }], ctorParameters: () => [], propDecorators: { length: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], mode: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtOtpComplete: [{ type: i0.Output, args: ["bahtOtpComplete"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-page-header>`: The top of a page: a way back, the title, what the page is for and its actions */
+export class BahtPageHeaderDirective {
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set description(v) {
+        assign(this.element, 'description', v);
+    }
+    /** Small line above the title. */
+    set eyebrow(v) {
+        assign(this.element, 'eyebrow', v);
+    }
+    set backLabel(v) {
+        assign(this.element, 'backLabel', v);
+    }
+    set backHref(v) {
+        assign(this.element, 'backHref', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The back link was pressed. Cancelable: `preventDefault()` to route yourself. */
+        this.bahtBack = output();
+        relay(this.element, 'baht-back', this.bahtBack);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPageHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtPageHeaderDirective, isStandalone: true, selector: "baht-page-header", inputs: { heading: "heading", description: "description", eyebrow: "eyebrow", backLabel: "backLabel", backHref: "backHref" }, outputs: { bahtBack: "bahtBack" }, exportAs: ["bahtPageHeader"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPageHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-page-header', exportAs: 'bahtPageHeader' }]
+        }], ctorParameters: () => [], propDecorators: { heading: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], eyebrow: [{
+                type: Input
+            }], backLabel: [{
+                type: Input
+            }], backHref: [{
+                type: Input
+            }], bahtBack: [{ type: i0.Output, args: ["bahtBack"] }] } });
+/** `<baht-pagination>`: Server-side pagination control: it never slices data — it only reports the page the user asked for via `baht-page-change`; the host fetches that page */
+export class BahtPaginationDirective {
+    set page(v) {
+        assign(this.element, 'page', v);
+    }
+    set totalPages(v) {
+        assign(this.element, 'totalPages', v);
+    }
+    /** 'numbered' = 1 … 4 5 6 … 20 · 'compact' = « Page 4 of 20 · 'cursor' = « Prev / Next » */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    /** Numbered pages shown on each side of the current page. */
+    set siblings(v) {
+        assign(this.element, 'siblings', v);
+    }
+    /** cursor variant only — whether a next/previous page is available. */
+    set hasNext(v) {
+        assign(this.element, 'hasNext', v);
+    }
+    set hasPrev(v) {
+        assign(this.element, 'hasPrev', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A page was picked. */
+        this.bahtPageChange = output();
+        /** Cursor mode: next or previous was pressed. */
+        this.bahtCursorChange = output();
+        relay(this.element, 'baht-page-change', this.bahtPageChange);
+        relay(this.element, 'baht-cursor-change', this.bahtCursorChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPaginationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtPaginationDirective, isStandalone: true, selector: "baht-pagination", inputs: { page: ["page", "page", num], totalPages: ["totalPages", "totalPages", num], variant: "variant", siblings: ["siblings", "siblings", num], hasNext: ["hasNext", "hasNext", booleanAttribute], hasPrev: ["hasPrev", "hasPrev", booleanAttribute] }, outputs: { bahtPageChange: "bahtPageChange", bahtCursorChange: "bahtCursorChange" }, exportAs: ["bahtPagination"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPaginationDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-pagination', exportAs: 'bahtPagination' }]
+        }], ctorParameters: () => [], propDecorators: { page: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], totalPages: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], variant: [{
+                type: Input
+            }], siblings: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], hasNext: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hasPrev: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtPageChange: [{ type: i0.Output, args: ["bahtPageChange"] }], bahtCursorChange: [{ type: i0.Output, args: ["bahtCursorChange"] }] } });
+/** `<baht-popover>`: A floating panel anchored to a trigger — filters, a quick-edit form, a hover card you click open */
+export class BahtPopoverDirective {
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    /** Accessible name of the panel. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Where the panel sits relative to the trigger. */
+    set placement(v) {
+        assign(this.element, 'placement', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The user opened or closed it. `detail: { open }`. */
+        this.bahtToggle = output();
+        relay(this.element, 'baht-toggle', this.bahtToggle);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPopoverDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtPopoverDirective, isStandalone: true, selector: "baht-popover", inputs: { open: ["open", "open", booleanAttribute], label: "label", placement: "placement" }, outputs: { bahtToggle: "bahtToggle" }, exportAs: ["bahtPopover"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtPopoverDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-popover', exportAs: 'bahtPopover' }]
+        }], ctorParameters: () => [], propDecorators: { open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], bahtToggle: [{ type: i0.Output, args: ["bahtToggle"] }] } });
+/** `<baht-progress>`: Progress bar */
+export class BahtProgressDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set tone(v) {
+        assign(this.element, 'tone', v);
+    }
+    set showLabel(v) {
+        assign(this.element, 'showLabel', v);
+    }
+    /** Accessible name for the progressbar. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtProgressDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtProgressDirective, isStandalone: true, selector: "baht-progress", inputs: { value: "value", tone: "tone", showLabel: ["showLabel", "showLabel", booleanAttribute], label: "label" }, exportAs: ["bahtProgress"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtProgressDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-progress', exportAs: 'bahtProgress' }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], tone: [{
+                type: Input
+            }], showLabel: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }] } });
+/** `<baht-progress-ring>`: Circular single-value "percent used" ring — the round counterpart to `<baht-progress>`'s linear bar */
+export class BahtProgressRingDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** 0-100, clamped. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set tone(v) {
+        assign(this.element, 'tone', v);
+    }
+    /** Caption under the percentage, e.g. "of budget used". */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Rendered pixel size (square). */
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtProgressRingDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtProgressRingDirective, isStandalone: true, selector: "baht-progress-ring", inputs: { value: ["value", "value", num], tone: "tone", label: "label", size: ["size", "size", num] }, exportAs: ["bahtProgressRing"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtProgressRingDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-progress-ring', exportAs: 'bahtProgressRing' }]
+        }], propDecorators: { value: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], tone: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], size: [{
+                type: Input,
+                args: [{ transform: num }]
+            }] } });
+/** `<baht-radio>` */
+export class BahtRadioDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRadioDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtRadioDirective, isStandalone: true, selector: "baht-radio", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtRadio"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRadioDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-radio', exportAs: 'bahtRadio' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-range>`: Range slider */
+export class BahtRangeDirective {
+    /** Current value. Standalone: a number. Field mode: `number | null` (null = untouched). */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Standalone lower bound; a field uses `field.min`. */
+    set min(v) {
+        assign(this.element, 'min', v);
+    }
+    /** Standalone upper bound; a field uses `field.max`. */
+    set max(v) {
+        assign(this.element, 'max', v);
+    }
+    /** Standalone step; a field uses `field.step`. */
+    set step(v) {
+        assign(this.element, 'step', v);
+    }
+    /** Standalone visible label; a field uses its label. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Show the current value next to the slider. */
+    set showValue(v) {
+        assign(this.element, 'showValue', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Standalone mode: the slider moved. `detail: { value }`. */
+        this.bahtChange = output();
+        /** Field mode: the slider moved. `detail: { key, value }`. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRangeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtRangeDirective, isStandalone: true, selector: "baht-range", inputs: { value: "value", min: ["min", "min", num], max: ["max", "max", num], step: ["step", "step", num], label: "label", showValue: ["showValue", "showValue", booleanAttribute], field: "field", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtChange: "bahtChange", bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtRange"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRangeDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-range', exportAs: 'bahtRange' }]
+        }], ctorParameters: () => [], propDecorators: { value: [{
+                type: Input
+            }], min: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], max: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], step: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], label: [{
+                type: Input
+            }], showValue: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], field: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-rating>`: Star rating */
+export class BahtRatingDirective {
+    /** Picked star count. Standalone: a number (`0` = none). Field mode: `number | null`. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Standalone star count; a field uses `field.max` instead. */
+    set max(v) {
+        assign(this.element, 'max', v);
+    }
+    /** Standalone accessible name for the radiogroup; a field uses its label. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Standalone mode: a star was picked. `detail: { value }` (0 = cleared). */
+        this.bahtChange = output();
+        /** Field mode: a star was picked. `detail: { key, value }` (null = cleared). */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRatingDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtRatingDirective, isStandalone: true, selector: "baht-rating", inputs: { value: "value", max: ["max", "max", num], label: "label", field: "field", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtChange: "bahtChange", bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtRating"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRatingDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-rating', exportAs: 'bahtRating' }]
+        }], ctorParameters: () => [], propDecorators: { value: [{
+                type: Input
+            }], max: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], label: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-record-bar>`: The bar over a record: what it is, and what can be done to it, kept in sight while the form below scrolls */
+export class BahtRecordBarDirective {
+    /** The lines naming the record, first one strongest. */
+    set lines(v) {
+        assign(this.element, 'lines', v);
+    }
+    set backHref(v) {
+        assign(this.element, 'backHref', v);
+    }
+    set backLabel(v) {
+        assign(this.element, 'backLabel', v);
+    }
+    /** `false` lets it scroll away with the page. */
+    set sticky(v) {
+        assign(this.element, 'sticky', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The back link was pressed. Cancelable: `preventDefault()` to route yourself. */
+        this.bahtBack = output();
+        relay(this.element, 'baht-back', this.bahtBack);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRecordBarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtRecordBarDirective, isStandalone: true, selector: "baht-record-bar", inputs: { lines: "lines", backHref: "backHref", backLabel: "backLabel", sticky: ["sticky", "sticky", booleanAttribute] }, outputs: { bahtBack: "bahtBack" }, exportAs: ["bahtRecordBar"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRecordBarDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-record-bar', exportAs: 'bahtRecordBar' }]
+        }], ctorParameters: () => [], propDecorators: { lines: [{
+                type: Input
+            }], backHref: [{
+                type: Input
+            }], backLabel: [{
+                type: Input
+            }], sticky: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtBack: [{ type: i0.Output, args: ["bahtBack"] }] } });
+/** `<baht-reference-dialog>`: A reference's records as a table in a modal: search one column or every column, build a filter, sort by a header, add, remove and reorder columns, page through, and press a row's first cell to pick it */
+export class BahtReferenceDialogDirective {
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    set heading(v) {
+        assign(this.element, 'heading', v);
+    }
+    set columns(v) {
+        assign(this.element, 'columns', v);
+    }
+    set lister(v) {
+        assign(this.element, 'lister', v);
+    }
+    /** The record the field holds now, marked in the table. */
+    set selected(v) {
+        assign(this.element, 'selected', v);
+    }
+    /** Every column on offer; without it, only `columns`. */
+    set walk(v) {
+        assign(this.element, 'walk', v);
+    }
+    /** The columns this person chose last time. Keys no longer on offer are dropped. */
+    set savedColumns(v) {
+        assign(this.element, 'savedColumns', v);
+    }
+    /** The filters this person saved; null hides saving. The host keeps them. */
+    set savedFilters(v) {
+        assign(this.element, 'savedFilters', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A record was picked. `detail: { key, label }`. */
+        this.bahtPick = output();
+        /** The modal was dismissed. */
+        this.bahtClose = output();
+        /** The columns were chosen. `detail: ColumnsChangeDetail`. */
+        this.bahtColumnsChange = output();
+        /** A filter was saved or deleted. `detail: { filters }`. */
+        this.bahtSavedFiltersChange = output();
+        relay(this.element, 'baht-pick', this.bahtPick);
+        relay(this.element, 'baht-close', this.bahtClose);
+        relay(this.element, 'baht-columns-change', this.bahtColumnsChange);
+        relay(this.element, 'baht-saved-filters-change', this.bahtSavedFiltersChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtReferenceDialogDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtReferenceDialogDirective, isStandalone: true, selector: "baht-reference-dialog", inputs: { open: ["open", "open", booleanAttribute], heading: "heading", columns: "columns", lister: "lister", selected: "selected", walk: "walk", savedColumns: "savedColumns", savedFilters: "savedFilters" }, outputs: { bahtPick: "bahtPick", bahtClose: "bahtClose", bahtColumnsChange: "bahtColumnsChange", bahtSavedFiltersChange: "bahtSavedFiltersChange" }, exportAs: ["bahtReferenceDialog"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtReferenceDialogDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-reference-dialog', exportAs: 'bahtReferenceDialog' }]
+        }], ctorParameters: () => [], propDecorators: { open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], heading: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], lister: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], walk: [{
+                type: Input
+            }], savedColumns: [{
+                type: Input
+            }], savedFilters: [{
+                type: Input
+            }], bahtPick: [{ type: i0.Output, args: ["bahtPick"] }], bahtClose: [{ type: i0.Output, args: ["bahtClose"] }], bahtColumnsChange: [{ type: i0.Output, args: ["bahtColumnsChange"] }], bahtSavedFiltersChange: [{ type: i0.Output, args: ["bahtSavedFiltersChange"] }] } });
+/** `<baht-reference-picker>`: Reference lookup: read-only input + magnifier opening a typeahead dropdown */
+export class BahtReferencePickerDirective {
+    /** Accessible name for the combobox + its option list (standalone; a field uses its label). */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Selected id (the reference's key). Field mode: `string | null`. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Human-readable label for `value`; falls back to showing the raw id. */
+    set display(v) {
+        assign(this.element, 'display', v);
+    }
+    set placeholder(v) {
+        assign(this.element, 'placeholder', v);
+    }
+    /** Marks the control invalid (styles + aria-invalid). */
+    set invalid(v) {
+        assign(this.element, 'invalid', v);
+    }
+    /** Optional link to the selected record, rendered as an external-link button. */
+    set href(v) {
+        assign(this.element, 'href', v);
+    }
+    /** Accessible name for the lookup button. */
+    set lookupLabel(v) {
+        assign(this.element, 'lookupLabel', v);
+    }
+    /** Debounce for search calls, ms (default 200). */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    /** Async search: term in, options out. Required for the dropdown to work (standalone). */
+    set fetcher(v) {
+        assign(this.element, 'fetcher', v);
+    }
+    /** Field mode: the record lookup (set by `<baht-form>` from `registry.references`). */
+    set lookup(v) {
+        assign(this.element, 'lookup', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Standalone mode: a record was picked or cleared. `detail: { value, label }`. */
+        this.bahtChange = output();
+        /** Field mode: a record was picked or cleared. `detail: { key, value }`. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtReferencePickerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtReferencePickerDirective, isStandalone: true, selector: "baht-reference-picker", inputs: { label: "label", value: "value", display: "display", placeholder: "placeholder", invalid: ["invalid", "invalid", booleanAttribute], href: "href", lookupLabel: "lookupLabel", debounce: ["debounce", "debounce", num], fetcher: "fetcher", lookup: "lookup", field: "field", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error" }, outputs: { bahtChange: "bahtChange", bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtReferencePicker"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtReferencePickerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-reference-picker', exportAs: 'bahtReferencePicker' }]
+        }], ctorParameters: () => [], propDecorators: { label: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], display: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], invalid: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], href: [{
+                type: Input
+            }], lookupLabel: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], fetcher: [{
+                type: Input
+            }], lookup: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-repeater>`: <baht-repeater> — array-of-rows control (spec 01 §10) */
+export class BahtRepeaterDirective {
+    /** Row-scoped errors from the host form, keyed `key[i].subKey`. */
+    set rowErrors(v) {
+        assign(this.element, 'rowErrors', v);
+    }
+    /** Rule-derived states of the row sub-fields, keyed `key[i].sub` (spec 02 §2a). Absent = every sub-field visible with its descriptor defaults. */
+    set rowStates(v) {
+        assign(this.element, 'rowStates', v);
+    }
+    /** Set by the host form: what makes a `reference` column searchable. */
+    set rowLookup(v) {
+        assign(this.element, 'rowLookup', v);
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRepeaterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtRepeaterDirective, isStandalone: true, selector: "baht-repeater", inputs: { rowErrors: "rowErrors", rowStates: "rowStates", rowLookup: "rowLookup", field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtRepeater"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRepeaterDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-repeater', exportAs: 'bahtRepeater' }]
+        }], ctorParameters: () => [], propDecorators: { rowErrors: [{
+                type: Input
+            }], rowStates: [{
+                type: Input
+            }], rowLookup: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-rule-builder>`: Edits a workflow's `rules` without code: "when all / any of <field> <is> <value>, then show / hide / make mandatory / set value / skip step" */
+export class BahtRuleBuilderDirective {
+    set workflow(v) {
+        assign(this.element, 'workflow', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A rule was edited. */
+        this.bahtChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRuleBuilderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtRuleBuilderDirective, isStandalone: true, selector: "baht-rule-builder", inputs: { workflow: "workflow" }, outputs: { bahtChange: "bahtChange" }, exportAs: ["bahtRuleBuilder"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtRuleBuilderDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-rule-builder', exportAs: 'bahtRuleBuilder' }]
+        }], ctorParameters: () => [], propDecorators: { workflow: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }] } });
+/** `<baht-saved-filters>`: ServiceNow's Save Filters: name the filter being built, apply a saved one, delete one */
+export class BahtSavedFiltersDirective {
+    set filters(v) {
+        assign(this.element, 'filters', v);
+    }
+    /** The filter Save would keep. */
+    set current(v) {
+        assign(this.element, 'current', v);
+    }
+    /** What can be filtered on now. */
+    set fields(v) {
+        assign(this.element, 'fields', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A saved filter was chosen. `detail: { value }`. */
+        this.bahtFilterPick = output();
+        /** One was saved or deleted. `detail: { filters }`. */
+        this.bahtSavedFiltersChange = output();
+        relay(this.element, 'baht-filter-pick', this.bahtFilterPick);
+        relay(this.element, 'baht-saved-filters-change', this.bahtSavedFiltersChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSavedFiltersDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtSavedFiltersDirective, isStandalone: true, selector: "baht-saved-filters", inputs: { filters: "filters", current: "current", fields: "fields" }, outputs: { bahtFilterPick: "bahtFilterPick", bahtSavedFiltersChange: "bahtSavedFiltersChange" }, exportAs: ["bahtSavedFilters"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSavedFiltersDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-saved-filters', exportAs: 'bahtSavedFilters' }]
+        }], ctorParameters: () => [], propDecorators: { filters: [{
+                type: Input
+            }], current: [{
+                type: Input
+            }], fields: [{
+                type: Input
+            }], bahtFilterPick: [{ type: i0.Output, args: ["bahtFilterPick"] }], bahtSavedFiltersChange: [{ type: i0.Output, args: ["bahtSavedFiltersChange"] }] } });
+/** `<baht-section>`: Section divider (`type: "section"`): heading + rule, no value */
+export class BahtSectionDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    /** Folded right now. */
+    set collapsed(v) {
+        assign(this.element, 'collapsed', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The user folded or unfolded it. `detail: { collapsed }`. */
+        this.bahtSectionToggle = output();
+        relay(this.element, 'baht-section-toggle', this.bahtSectionToggle);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtSectionDirective, isStandalone: true, selector: "baht-section", inputs: { field: "field", collapsed: ["collapsed", "collapsed", booleanAttribute] }, outputs: { bahtSectionToggle: "bahtSectionToggle" }, exportAs: ["bahtSection"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSectionDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-section', exportAs: 'bahtSection' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], collapsed: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtSectionToggle: [{ type: i0.Output, args: ["bahtSectionToggle"] }] } });
+/** `<baht-select>`: Single-choice dropdown */
+export class BahtSelectDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSelectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtSelectDirective, isStandalone: true, selector: "baht-select", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtSelect"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSelectDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-select', exportAs: 'bahtSelect' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-skeleton>`: Loading placeholder (opacity pulse — the 20baht system bans gradients in core UI, so no shimmer) */
+export class BahtSkeletonDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    set width(v) {
+        assign(this.element, 'width', v);
+    }
+    set height(v) {
+        assign(this.element, 'height', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSkeletonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtSkeletonDirective, isStandalone: true, selector: "baht-skeleton", inputs: { variant: "variant", width: "width", height: "height" }, exportAs: ["bahtSkeleton"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSkeletonDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-skeleton', exportAs: 'bahtSkeleton' }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }] } });
+/** `<baht-sparkline>`: Micro trend line — no axes, no ticks, no tooltip */
+export class BahtSparklineDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** The points, oldest first. Fewer than two points renders nothing. */
+    set values(v) {
+        assign(this.element, 'values', v);
+    }
+    /** Drawing width in px. */
+    set width(v) {
+        assign(this.element, 'width', v);
+    }
+    /** Drawing height in px. */
+    set height(v) {
+        assign(this.element, 'height', v);
+    }
+    /** Mark the newest point with an accent dot. */
+    set accentLast(v) {
+        assign(this.element, 'accentLast', v);
+    }
+    /** Line color; defaults to the de-emphasis chart token. */
+    set color(v) {
+        assign(this.element, 'color', v);
+    }
+    /** Accessible name; falls back to a plain "Trend of N points" sentence. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSparklineDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtSparklineDirective, isStandalone: true, selector: "baht-sparkline", inputs: { values: "values", width: ["width", "width", num], height: ["height", "height", num], accentLast: ["accentLast", "accentLast", booleanAttribute], color: "color", label: "label" }, exportAs: ["bahtSparkline"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSparklineDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-sparkline', exportAs: 'bahtSparkline' }]
+        }], propDecorators: { values: [{
+                type: Input
+            }], width: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], height: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], accentLast: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], color: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }] } });
+/** `<baht-spinner>`: Loading spinner — the single animated icon the 20baht system allows */
+export class BahtSpinnerDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSpinnerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtSpinnerDirective, isStandalone: true, selector: "baht-spinner", inputs: { size: "size", label: "label" }, exportAs: ["bahtSpinner"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSpinnerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-spinner', exportAs: 'bahtSpinner' }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }] } });
+/** `<baht-split-button>`: Split button: a main action plus a ▾ toggle that opens a menu of related actions (NOTES 2026-10-31) */
+export class BahtSplitButtonDirective {
+    /** Main action label. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** Shortcut for the main action, e.g. `alt+s` (see `<baht-button shortcut>`). */
+    set shortcut(v) {
+        assign(this.element, 'shortcut', v);
+    }
+    /** Menu entries. Set as a property: `el.items = [...]`. */
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    /** Menu edge aligned with the button: `'end'` (default, right in LTR) or `'start'`. */
+    set align(v) {
+        assign(this.element, 'align', v);
+    }
+    /** Accessible name of the ▾ toggle. Defaults to the localized "More actions". */
+    set menuLabel(v) {
+        assign(this.element, 'menuLabel', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The main action was activated (click or its shortcut). */
+        this.bahtClick = output();
+        /** A menu item was picked. `detail: { value, item }`. */
+        this.bahtSelect = output();
+        relay(this.element, 'baht-click', this.bahtClick);
+        relay(this.element, 'baht-select', this.bahtSelect);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSplitButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtSplitButtonDirective, isStandalone: true, selector: "baht-split-button", inputs: { label: "label", variant: "variant", size: "size", disabled: ["disabled", "disabled", booleanAttribute], shortcut: "shortcut", items: "items", align: "align", menuLabel: "menuLabel" }, outputs: { bahtClick: "bahtClick", bahtSelect: "bahtSelect" }, exportAs: ["bahtSplitButton"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSplitButtonDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-split-button', exportAs: 'bahtSplitButton' }]
+        }], ctorParameters: () => [], propDecorators: { label: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], shortcut: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], menuLabel: [{
+                type: Input
+            }], bahtClick: [{ type: i0.Output, args: ["bahtClick"] }], bahtSelect: [{ type: i0.Output, args: ["bahtSelect"] }] } });
+/** `<baht-stat>`: Stat tile: label, one figure, an optional delta against a named period and an optional sparkline */
+export class BahtStatDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Sentence-case caption above the figure, no trailing colon. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** The figure. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** How the figure reads: number | currency | percent | compact. */
+    set format(v) {
+        assign(this.element, 'format', v);
+    }
+    /** ISO currency code for `format="currency"` (THB renders `฿`). */
+    set currency(v) {
+        assign(this.element, 'currency', v);
+    }
+    /** Change against the previous period. `null` hides the delta row. With `delta-kind="pct"` it is a percentage (18 → "18%"); with `"abs"` it is a raw amount rendered with this tile's `format`. */
+    set delta(v) {
+        assign(this.element, 'delta', v);
+    }
+    /** Whether `delta` is a percentage or an absolute amount. */
+    set deltaKind(v) {
+        assign(this.element, 'deltaKind', v);
+    }
+    /** What the delta is measured against, e.g. "vs August". With no `delta` it is still rendered on its own as a muted caption, so a figure can name its period. */
+    set deltaLabel(v) {
+        assign(this.element, 'deltaLabel', v);
+    }
+    /** Is a rise good news? Spending tiles set `up-is-good="false"`. */
+    set upIsGood(v) {
+        assign(this.element, 'upIsGood', v);
+    }
+    /** Recent points drawn as a muted sparkline with an accent on the newest. */
+    set trend(v) {
+        assign(this.element, 'trend', v);
+    }
+    /** `hero` is the one 48px+ figure a view leads with. */
+    set size(v) {
+        assign(this.element, 'size', v);
+    }
+    /** Icon name from the curated set (see icons.ts), shown in a chip before the label. */
+    set icon(v) {
+        assign(this.element, 'icon', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStatDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtStatDirective, isStandalone: true, selector: "baht-stat", inputs: { label: "label", value: ["value", "value", num], format: "format", currency: "currency", delta: "delta", deltaKind: "deltaKind", deltaLabel: "deltaLabel", upIsGood: ["upIsGood", "upIsGood", booleanAttribute], trend: "trend", size: "size", icon: "icon" }, exportAs: ["bahtStat"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStatDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-stat', exportAs: 'bahtStat' }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], value: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], format: [{
+                type: Input
+            }], currency: [{
+                type: Input
+            }], delta: [{
+                type: Input
+            }], deltaKind: [{
+                type: Input
+            }], deltaLabel: [{
+                type: Input
+            }], upIsGood: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], trend: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }] } });
+/** `<baht-stat-chart>`: Big single-number stat (report type "count") */
+export class BahtStatChartDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set total(v) {
+        assign(this.element, 'total', v);
+    }
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Overrides the number color (defaults to the primary token). */
+    set color(v) {
+        assign(this.element, 'color', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStatChartDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtStatChartDirective, isStandalone: true, selector: "baht-stat-chart", inputs: { total: ["total", "total", num], label: "label", color: "color" }, exportAs: ["bahtStatChart"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStatChartDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-stat-chart', exportAs: 'bahtStatChart' }]
+        }], propDecorators: { total: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], label: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }] } });
+/** `<baht-steps>`: <baht-steps> — wizard progress indicator (spec 03) */
+export class BahtStepsDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    /** Step labels in order. */
+    set steps(v) {
+        assign(this.element, 'steps', v);
+    }
+    /** 0-based index of the current step. */
+    set current(v) {
+        assign(this.element, 'current', v);
+    }
+    /** 'default' = horizontal numbered markers; 'sidebar' = vertical nav list, current pilled; 'chevron' = a joined strip of states, scrolling sideways when it does not fit. */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    /** chevron: tick the steps before the current one. Off when the strip lists states, not progress. */
+    set showDone(v) {
+        assign(this.element, 'showDone', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStepsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtStepsDirective, isStandalone: true, selector: "baht-steps", inputs: { steps: "steps", current: ["current", "current", num], variant: "variant", showDone: ["showDone", "showDone", booleanAttribute] }, exportAs: ["bahtSteps"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtStepsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-steps', exportAs: 'bahtSteps' }]
+        }], propDecorators: { steps: [{
+                type: Input
+            }], current: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], variant: [{
+                type: Input
+            }], showDone: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+/** `<baht-swipe-row>`: Row container for touch lists: the children are the row, `actions` sit behind it on the right and are revealed by swiping the row left */
+export class BahtSwipeRowDirective {
+    /** Actions revealed by the swipe, in order: `{ key, label, tone? }`. */
+    set actions(v) {
+        assign(this.element, 'actions', v);
+    }
+    /** Revealed state. Reflected; set it to open or close the row from the host. */
+    set open(v) {
+        assign(this.element, 'open', v);
+    }
+    /** Accessible name of the action group (default: the i18n `rowActions` string). */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A revealed action was pressed. */
+        this.bahtAction = output();
+        relay(this.element, 'baht-action', this.bahtAction);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSwipeRowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtSwipeRowDirective, isStandalone: true, selector: "baht-swipe-row", inputs: { actions: "actions", open: ["open", "open", booleanAttribute], label: "label" }, outputs: { bahtAction: "bahtAction" }, exportAs: ["bahtSwipeRow"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtSwipeRowDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-swipe-row', exportAs: 'bahtSwipeRow' }]
+        }], ctorParameters: () => [], propDecorators: { actions: [{
+                type: Input
+            }], open: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], label: [{
+                type: Input
+            }], bahtAction: [{ type: i0.Output, args: ["bahtAction"] }] } });
+/** `<baht-table>`: Server-side data table */
+export class BahtTableDirective {
+    /** Rows of the CURRENT page. */
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    /** column key -> display name, or a reference column with `fields` (property); empty = derive keys from the first row (`snake_case` -> `Title Case`). */
+    set columns(v) {
+        assign(this.element, 'columns', v);
+    }
+    set loading(v) {
+        assign(this.element, 'loading', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    set errorMessage(v) {
+        assign(this.element, 'errorMessage', v);
+    }
+    set emptyMessage(v) {
+        assign(this.element, 'emptyMessage', v);
+    }
+    /** Row-number column (No.). Offset lets numbering continue across pages. */
+    set showIndex(v) {
+        assign(this.element, 'showIndex', v);
+    }
+    set indexOffset(v) {
+        assign(this.element, 'indexOffset', v);
+    }
+    set skeletonRows(v) {
+        assign(this.element, 'skeletonRows', v);
+    }
+    /** Which row key identifies a row in baht-row-click detail.id (e.g. 'group_id'). */
+    set rowKey(v) {
+        assign(this.element, 'rowKey', v);
+    }
+    /** Rows emit baht-row-click + get hover/keyboard affordances. */
+    set clickable(v) {
+        assign(this.element, 'clickable', v);
+    }
+    /** Custom cell renderers by column key, dotted keys included (functions — a property, never JSON). */
+    set renderers(v) {
+        assign(this.element, 'renderers', v);
+    }
+    /** Subset + order of columns to render (dotted keys allowed); empty/omitted = show all top-level columns. */
+    set visibleColumns(v) {
+        assign(this.element, 'visibleColumns', v);
+    }
+    /** Group the page's rows by this (dotted) column key — or a function of the row (property). Unset = no grouping. */
+    set groupBy(v) {
+        assign(this.element, 'groupBy', v);
+    }
+    /** Group header content (property); default is "Column: value (n)". */
+    set groupLabel(v) {
+        assign(this.element, 'groupLabel', v);
+    }
+    /** Group headers are disclosures (click to collapse). Set the JS property to `false` for static headers. */
+    set groupCollapsible(v) {
+        assign(this.element, 'groupCollapsible', v);
+    }
+    /** Start every group collapsed (per page — resets when `items`/`page` change). */
+    set groupCollapsed(v) {
+        assign(this.element, 'groupCollapsed', v);
+    }
+    /** Drop the column header row (list-style tables, e.g. grouped ledgers). */
+    set hideHeader(v) {
+        assign(this.element, 'hideHeader', v);
+    }
+    /** Built-in "Columns" toggle — derives its options from `columns`/rows. Set `column-picker="false"` to hide it. */
+    set columnPicker(v) {
+        assign(this.element, 'columnPicker', v);
+    }
+    /** Total matching rows across all pages — renders "{n} results" in the toolbar. Unset = no count. */
+    set total(v) {
+        assign(this.element, 'total', v);
+    }
+    set selectable(v) {
+        assign(this.element, 'selectable', v);
+    }
+    set selected(v) {
+        assign(this.element, 'selected', v);
+    }
+    /** Make every column sortable (or set `sortable` per column in `columns`). */
+    set sortable(v) {
+        assign(this.element, 'sortable', v);
+    }
+    /** Current sort, mirrored in the header (`aria-sort`); the host keeps it in sync with the fetch. */
+    set sort(v) {
+        assign(this.element, 'sort', v);
+    }
+    /** A Filter button: a condition builder over every column, and the applied conditions as breadcrumbs. */
+    set filterable(v) {
+        assign(this.element, 'filterable', v);
+    }
+    /** The applied filter; the host applies it and keeps it in sync. */
+    set filter(v) {
+        assign(this.element, 'filter', v);
+    }
+    /** The filters this person saved; null hides saving. The host keeps them. */
+    set savedFilters(v) {
+        assign(this.element, 'savedFilters', v);
+    }
+    /** Trailing "..." button per row; emits `baht-row-actions { row, index, id }`. */
+    set rowActions(v) {
+        assign(this.element, 'rowActions', v);
+    }
+    set page(v) {
+        assign(this.element, 'page', v);
+    }
+    set totalPages(v) {
+        assign(this.element, 'totalPages', v);
+    }
+    /** Keep the footer with one page too, so a list always shows where the pages are. */
+    set alwaysPaginate(v) {
+        assign(this.element, 'alwaysPaginate', v);
+    }
+    /** Switch the footer to Prev/Next (cursor-based API, no total count). */
+    set cursorMode(v) {
+        assign(this.element, 'cursorMode', v);
+    }
+    set hasNext(v) {
+        assign(this.element, 'hasNext', v);
+    }
+    set hasPrev(v) {
+        assign(this.element, 'hasPrev', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A row was pressed. */
+        this.bahtRowClick = output();
+        /** The selection changed. */
+        this.bahtSelectionChange = output();
+        /** A sortable header was pressed. */
+        this.bahtSortChange = output();
+        /** The column picker was confirmed. */
+        this.bahtColumnsChange = output();
+        /** The filter changed. */
+        this.bahtFilterChange = output();
+        /** A group was collapsed or expanded. */
+        this.bahtGroupToggle = output();
+        /** A row's actions button was pressed. */
+        this.bahtRowActions = output();
+        relay(this.element, 'baht-row-click', this.bahtRowClick);
+        relay(this.element, 'baht-selection-change', this.bahtSelectionChange);
+        relay(this.element, 'baht-sort-change', this.bahtSortChange);
+        relay(this.element, 'baht-columns-change', this.bahtColumnsChange);
+        relay(this.element, 'baht-filter-change', this.bahtFilterChange);
+        relay(this.element, 'baht-group-toggle', this.bahtGroupToggle);
+        relay(this.element, 'baht-row-actions', this.bahtRowActions);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtTableDirective, isStandalone: true, selector: "baht-table", inputs: { items: "items", columns: "columns", loading: ["loading", "loading", booleanAttribute], error: ["error", "error", booleanAttribute], errorMessage: "errorMessage", emptyMessage: "emptyMessage", showIndex: ["showIndex", "showIndex", booleanAttribute], indexOffset: ["indexOffset", "indexOffset", num], skeletonRows: ["skeletonRows", "skeletonRows", num], rowKey: "rowKey", clickable: ["clickable", "clickable", booleanAttribute], renderers: "renderers", visibleColumns: "visibleColumns", groupBy: "groupBy", groupLabel: "groupLabel", groupCollapsible: ["groupCollapsible", "groupCollapsible", booleanAttribute], groupCollapsed: ["groupCollapsed", "groupCollapsed", booleanAttribute], hideHeader: ["hideHeader", "hideHeader", booleanAttribute], columnPicker: ["columnPicker", "columnPicker", booleanAttribute], total: ["total", "total", num], selectable: ["selectable", "selectable", booleanAttribute], selected: "selected", sortable: ["sortable", "sortable", booleanAttribute], sort: "sort", filterable: ["filterable", "filterable", booleanAttribute], filter: "filter", savedFilters: "savedFilters", rowActions: ["rowActions", "rowActions", booleanAttribute], page: ["page", "page", num], totalPages: ["totalPages", "totalPages", num], alwaysPaginate: ["alwaysPaginate", "alwaysPaginate", booleanAttribute], cursorMode: ["cursorMode", "cursorMode", booleanAttribute], hasNext: ["hasNext", "hasNext", booleanAttribute], hasPrev: ["hasPrev", "hasPrev", booleanAttribute] }, outputs: { bahtRowClick: "bahtRowClick", bahtSelectionChange: "bahtSelectionChange", bahtSortChange: "bahtSortChange", bahtColumnsChange: "bahtColumnsChange", bahtFilterChange: "bahtFilterChange", bahtGroupToggle: "bahtGroupToggle", bahtRowActions: "bahtRowActions" }, exportAs: ["bahtTable"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-table', exportAs: 'bahtTable' }]
+        }], ctorParameters: () => [], propDecorators: { items: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], loading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], errorMessage: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], showIndex: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], indexOffset: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], skeletonRows: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], rowKey: [{
+                type: Input
+            }], clickable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], renderers: [{
+                type: Input
+            }], visibleColumns: [{
+                type: Input
+            }], groupBy: [{
+                type: Input
+            }], groupLabel: [{
+                type: Input
+            }], groupCollapsible: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], groupCollapsed: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hideHeader: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], columnPicker: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], total: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], selectable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], selected: [{
+                type: Input
+            }], sortable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], sort: [{
+                type: Input
+            }], filterable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], filter: [{
+                type: Input
+            }], savedFilters: [{
+                type: Input
+            }], rowActions: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], page: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], totalPages: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], alwaysPaginate: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], cursorMode: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hasNext: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hasPrev: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtRowClick: [{ type: i0.Output, args: ["bahtRowClick"] }], bahtSelectionChange: [{ type: i0.Output, args: ["bahtSelectionChange"] }], bahtSortChange: [{ type: i0.Output, args: ["bahtSortChange"] }], bahtColumnsChange: [{ type: i0.Output, args: ["bahtColumnsChange"] }], bahtFilterChange: [{ type: i0.Output, args: ["bahtFilterChange"] }], bahtGroupToggle: [{ type: i0.Output, args: ["bahtGroupToggle"] }], bahtRowActions: [{ type: i0.Output, args: ["bahtRowActions"] }] } });
+/** `<baht-tabs>`: Tabs (APG tab pattern) */
+export class BahtTabsDirective {
+    /** The tab strip. Set as a property: `el.tabs = [...]`. */
+    set tabs(v) {
+        assign(this.element, 'tabs', v);
+    }
+    /** Selected tab key. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Accessible name of the tab list. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** `automatic` (default): arrows select. `manual`: arrows focus, Enter/Space selects. */
+    set activation(v) {
+        assign(this.element, 'activation', v);
+    }
+    /** `line` (default): an underline strip. `pill`: rounded chips; the active fill is `--baht-tabs-pill-active`. */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The user selected a tab. `detail: { value }`. Setting `value` does not fire it. */
+        this.bahtChange = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTabsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtTabsDirective, isStandalone: true, selector: "baht-tabs", inputs: { tabs: "tabs", value: "value", label: "label", activation: "activation", variant: "variant" }, outputs: { bahtChange: "bahtChange", valueChange: "valueChange" }, exportAs: ["bahtTabs"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTabsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-tabs', exportAs: 'bahtTabs' }]
+        }], ctorParameters: () => [], propDecorators: { tabs: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], activation: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-tags>`: Creatable chip input: value is `string[]` (unique, trimmed, in entry order) */
+export class BahtTagsDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTagsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtTagsDirective, isStandalone: true, selector: "baht-tags", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtTags"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTagsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-tags', exportAs: 'bahtTags' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-text>`: Static text block (`type: "label"`): no value, no emits. */
+export class BahtTextDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtTextDirective, isStandalone: true, selector: "baht-text", inputs: { field: "field" }, exportAs: ["bahtText"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTextDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-text', exportAs: 'bahtText' }]
+        }], propDecorators: { field: [{
+                type: Input
+            }] } });
+/** `<baht-textarea>` */
+export class BahtTextareaDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTextareaDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtTextareaDirective, isStandalone: true, selector: "baht-textarea", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtTextarea"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTextareaDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-textarea', exportAs: 'bahtTextarea' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-theme-toggle>`: Light / dark switch for the 20baht themes */
+export class BahtThemeToggleDirective {
+    /** Current theme. Setting it applies it to the target (not saved, no event). */
+    set theme(v) {
+        assign(this.element, 'theme', v);
+    }
+    /** Theme when nothing is saved and the target has none: `light`, `dark`, or `system`. */
+    set default(v) {
+        assign(this.element, 'default', v);
+    }
+    /** CSS selector of the element that carries `data-baht-theme`. Default: `<html>`. */
+    set target(v) {
+        assign(this.element, 'target', v);
+    }
+    /** localStorage key for the user's choice; `""` turns persistence off. */
+    set storageKey(v) {
+        assign(this.element, 'storageKey', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The user switched theme. `detail: { theme: 'light' | 'dark' }`. */
+        this.bahtThemeChange = output();
+        relay(this.element, 'baht-theme-change', this.bahtThemeChange);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtThemeToggleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtThemeToggleDirective, isStandalone: true, selector: "baht-theme-toggle", inputs: { theme: "theme", default: "default", target: "target", storageKey: "storageKey" }, outputs: { bahtThemeChange: "bahtThemeChange" }, exportAs: ["bahtThemeToggle"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtThemeToggleDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-theme-toggle', exportAs: 'bahtThemeToggle' }]
+        }], ctorParameters: () => [], propDecorators: { theme: [{
+                type: Input
+            }], default: [{
+                type: Input
+            }], target: [{
+                type: Input
+            }], storageKey: [{
+                type: Input
+            }], bahtThemeChange: [{ type: i0.Output, args: ["bahtThemeChange"] }] } });
+/** `<baht-timeline>`: Vertical timeline (run history, audit log) */
+export class BahtTimelineDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set items(v) {
+        assign(this.element, 'items', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTimelineDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtTimelineDirective, isStandalone: true, selector: "baht-timeline", inputs: { items: "items" }, exportAs: ["bahtTimeline"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTimelineDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-timeline', exportAs: 'bahtTimeline' }]
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
+/** `<baht-toast>`: Toast host — put ONE <baht-toast> on the page and call show(): const toast = document.querySelector('baht-toast'); toast.show({ message: 'Saved.', tone: 'success' }); Copy: short and dry ("Saved.", not "Successfully saved your changes!"). */
+export class BahtToastDirective {
+    /** Default auto-dismiss (ms) when show() gets no duration. */
+    set duration(v) {
+        assign(this.element, 'duration', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** A toast was dismissed. */
+        this.bahtDismiss = output();
+        relay(this.element, 'baht-dismiss', this.bahtDismiss);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtToastDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtToastDirective, isStandalone: true, selector: "baht-toast", inputs: { duration: ["duration", "duration", num] }, outputs: { bahtDismiss: "bahtDismiss" }, exportAs: ["bahtToast"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtToastDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-toast', exportAs: 'bahtToast' }]
+        }], ctorParameters: () => [], propDecorators: { duration: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtDismiss: [{ type: i0.Output, args: ["bahtDismiss"] }] } });
+/** `<baht-toggle>` */
+export class BahtToggleDirective {
+    set field(v) {
+        assign(this.element, 'field', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set readonly(v) {
+        assign(this.element, 'readonly', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Append the localized "(optional)" marker to the label when not required (set by <baht-form show-optional>). */
+    set showOptional(v) {
+        assign(this.element, 'showOptional', v);
+    }
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    /** Debounce for typed edits (ms); unset = BahtFieldBase.defaultDebounce. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Field mode: the user edited the value. */
+        this.bahtInput = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-input', this.bahtInput);
+        relay(this.element, 'baht-input', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtToggleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtToggleDirective, isStandalone: true, selector: "baht-toggle", inputs: { field: "field", value: "value", disabled: ["disabled", "disabled", booleanAttribute], readonly: ["readonly", "readonly", booleanAttribute], required: ["required", "required", booleanAttribute], showOptional: ["showOptional", "showOptional", booleanAttribute], error: "error", debounce: ["debounce", "debounce", num] }, outputs: { bahtInput: "bahtInput", valueChange: "valueChange" }, exportAs: ["bahtToggle"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtToggleDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-toggle', exportAs: 'bahtToggle' }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], readonly: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showOptional: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], bahtInput: [{ type: i0.Output, args: ["bahtInput"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-tooltip>`: Hover/focus tooltip */
+export class BahtTooltipDirective {
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+    }
+    set text(v) {
+        assign(this.element, 'text', v);
+    }
+    set position(v) {
+        assign(this.element, 'position', v);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.5", type: BahtTooltipDirective, isStandalone: true, selector: "baht-tooltip", inputs: { text: "text", position: "position" }, exportAs: ["bahtTooltip"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-tooltip', exportAs: 'bahtTooltip' }]
+        }], propDecorators: { text: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }] } });
+/** `<baht-typeahead>`: Text input with suggestions (autocomplete) */
+export class BahtTypeaheadDirective {
+    /** Accessible name (also the listbox name). */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** The text. Controlled: re-feed after `baht-change` (or don't — the input keeps what was typed). */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set placeholder(v) {
+        assign(this.element, 'placeholder', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    /** Marks the control invalid (styles + aria-invalid). */
+    set invalid(v) {
+        assign(this.element, 'invalid', v);
+    }
+    /** Static suggestion list, filtered client-side. Ignored when `fetcher` is set. */
+    set options(v) {
+        assign(this.element, 'options', v);
+    }
+    /** Async suggestions: term in, options out. Errors show as "no matches". */
+    set fetcher(v) {
+        assign(this.element, 'fetcher', v);
+    }
+    /** Quiet time (ms) before the host hears the text and suggestions are (re)computed. */
+    set debounce(v) {
+        assign(this.element, 'debounce', v);
+    }
+    /** Characters typed before suggestions appear (0 = suggest on focus/arrow too). */
+    set minChars(v) {
+        assign(this.element, 'minChars', v);
+    }
+    /** Cap on suggestions shown. */
+    set maxItems(v) {
+        assign(this.element, 'maxItems', v);
+    }
+    /** false = the text must be a picked option; blur reverts otherwise. */
+    set freeText(v) {
+        assign(this.element, 'freeText', v);
+    }
+    /** HTML autocomplete token forwarded to the input ('off' keeps the browser's own list away). */
+    set autocomplete(v) {
+        assign(this.element, 'autocomplete', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The text or the picked option changed. */
+        this.bahtChange = output();
+        /** An option was picked. */
+        this.bahtSelect = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-select', this.bahtSelect);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTypeaheadDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtTypeaheadDirective, isStandalone: true, selector: "baht-typeahead", inputs: { label: "label", value: "value", placeholder: "placeholder", disabled: ["disabled", "disabled", booleanAttribute], invalid: ["invalid", "invalid", booleanAttribute], options: "options", fetcher: "fetcher", debounce: ["debounce", "debounce", num], minChars: ["minChars", "minChars", num], maxItems: ["maxItems", "maxItems", num], freeText: ["freeText", "freeText", booleanAttribute], autocomplete: "autocomplete" }, outputs: { bahtChange: "bahtChange", bahtSelect: "bahtSelect", valueChange: "valueChange" }, exportAs: ["bahtTypeahead"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtTypeaheadDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-typeahead', exportAs: 'bahtTypeahead' }]
+        }], ctorParameters: () => [], propDecorators: { label: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], invalid: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], options: [{
+                type: Input
+            }], fetcher: [{
+                type: Input
+            }], debounce: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], minChars: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], maxItems: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], freeText: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], autocomplete: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtSelect: [{ type: i0.Output, args: ["bahtSelect"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-upload>`: File upload against an HTTP endpoint */
+export class BahtUploadDirective {
+    /** Endpoint that receives the file and returns its stored URL. Required. */
+    set url(v) {
+        assign(this.element, 'url', v);
+    }
+    /** HTTP method for the upload request. */
+    set method(v) {
+        assign(this.element, 'method', v);
+    }
+    /** Form-data key the file is sent under. */
+    set fieldName(v) {
+        assign(this.element, 'fieldName', v);
+    }
+    /** Where the stored URL lives in a JSON response (dotted path). Empty = the body itself. */
+    set responseKey(v) {
+        assign(this.element, 'responseKey', v);
+    }
+    /** Extra request headers (e.g. Authorization). Property only. */
+    set headers(v) {
+        assign(this.element, 'headers', v);
+    }
+    /** Send cookies on cross-origin requests. */
+    set withCredentials(v) {
+        assign(this.element, 'withCredentials', v);
+    }
+    /** Stored URL(s). `string`, `string[]` when `multiple`, or `null`. Property only. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** Visible label. */
+    set label(v) {
+        assign(this.element, 'label', v);
+    }
+    /** Helper text under the control. Defaults to the accept / size limits when set. */
+    set hint(v) {
+        assign(this.element, 'hint', v);
+    }
+    /** Native `accept` filter (`.pdf,image/*`). */
+    set accept(v) {
+        assign(this.element, 'accept', v);
+    }
+    /** Allow several files; the value becomes an array. */
+    set multiple(v) {
+        assign(this.element, 'multiple', v);
+    }
+    /** Reject files over this many bytes before sending. */
+    set maxSize(v) {
+        assign(this.element, 'maxSize', v);
+    }
+    set disabled(v) {
+        assign(this.element, 'disabled', v);
+    }
+    set required(v) {
+        assign(this.element, 'required', v);
+    }
+    /** Validation message to display (marks the control invalid). */
+    set error(v) {
+        assign(this.element, 'error', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The uploaded files changed. */
+        this.bahtChange = output();
+        /** A file started uploading. */
+        this.bahtUploadStart = output();
+        /** Upload progress. */
+        this.bahtUploadProgress = output();
+        /** An upload failed. */
+        this.bahtUploadError = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-upload-start', this.bahtUploadStart);
+        relay(this.element, 'baht-upload-progress', this.bahtUploadProgress);
+        relay(this.element, 'baht-upload-error', this.bahtUploadError);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtUploadDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtUploadDirective, isStandalone: true, selector: "baht-upload", inputs: { url: "url", method: "method", fieldName: "fieldName", responseKey: "responseKey", headers: "headers", withCredentials: ["withCredentials", "withCredentials", booleanAttribute], value: "value", label: "label", hint: "hint", accept: "accept", multiple: ["multiple", "multiple", booleanAttribute], maxSize: ["maxSize", "maxSize", num], disabled: ["disabled", "disabled", booleanAttribute], required: ["required", "required", booleanAttribute], error: "error" }, outputs: { bahtChange: "bahtChange", bahtUploadStart: "bahtUploadStart", bahtUploadProgress: "bahtUploadProgress", bahtUploadError: "bahtUploadError" }, exportAs: ["bahtUpload"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtUploadDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-upload', exportAs: 'bahtUpload' }]
+        }], ctorParameters: () => [], propDecorators: { url: [{
+                type: Input
+            }], method: [{
+                type: Input
+            }], fieldName: [{
+                type: Input
+            }], responseKey: [{
+                type: Input
+            }], headers: [{
+                type: Input
+            }], withCredentials: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], value: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], accept: [{
+                type: Input
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], maxSize: [{
+                type: Input,
+                args: [{ transform: num }]
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], error: [{
+                type: Input
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtUploadStart: [{ type: i0.Output, args: ["bahtUploadStart"] }], bahtUploadProgress: [{ type: i0.Output, args: ["bahtUploadProgress"] }], bahtUploadError: [{ type: i0.Output, args: ["bahtUploadError"] }] } });
+/** `<baht-wizard>`: Pages filled in order, checked as you go */
+export class BahtWizardDirective {
+    set steps(v) {
+        assign(this.element, 'steps', v);
+    }
+    /** Key of the open page; the first when unset or unknown. */
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    /** `chevron` shows a progress strip you read; `tabs` a strip you can click to go anywhere. */
+    set variant(v) {
+        assign(this.element, 'variant', v);
+    }
+    /** May this page be left? Unset: every page passes. */
+    set validateStep(v) {
+        assign(this.element, 'validateStep', v);
+    }
+    set backLabel(v) {
+        assign(this.element, 'backLabel', v);
+    }
+    set nextLabel(v) {
+        assign(this.element, 'nextLabel', v);
+    }
+    set finishLabel(v) {
+        assign(this.element, 'finishLabel', v);
+    }
+    /** Keeps the buttons from running twice while the host is working. */
+    set busy(v) {
+        assign(this.element, 'busy', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** The page changed. `detail: { value }`. */
+        this.bahtChange = output();
+        /** Every page passed. */
+        this.bahtFinish = output();
+        /** The value the user picked or typed, for `[(value)]`. */
+        this.valueChange = output();
+        relay(this.element, 'baht-change', this.bahtChange);
+        relay(this.element, 'baht-finish', this.bahtFinish);
+        relay(this.element, 'baht-change', this.valueChange, (d) => d.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtWizardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtWizardDirective, isStandalone: true, selector: "baht-wizard", inputs: { steps: "steps", value: "value", variant: "variant", validateStep: "validateStep", backLabel: "backLabel", nextLabel: "nextLabel", finishLabel: "finishLabel", busy: ["busy", "busy", booleanAttribute] }, outputs: { bahtChange: "bahtChange", bahtFinish: "bahtFinish", valueChange: "valueChange" }, exportAs: ["bahtWizard"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtWizardDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-wizard', exportAs: 'bahtWizard' }]
+        }], ctorParameters: () => [], propDecorators: { steps: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], validateStep: [{
+                type: Input
+            }], backLabel: [{
+                type: Input
+            }], nextLabel: [{
+                type: Input
+            }], finishLabel: [{
+                type: Input
+            }], busy: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], bahtChange: [{ type: i0.Output, args: ["bahtChange"] }], bahtFinish: [{ type: i0.Output, args: ["bahtFinish"] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }] } });
+/** `<baht-workflow>`: <baht-workflow> — the optional brain (spec 03) */
+export class BahtWorkflowDirective {
+    set workflow(v) {
+        assign(this.element, 'workflow', v);
+    }
+    set value(v) {
+        assign(this.element, 'value', v);
+    }
+    set registry(v) {
+        assign(this.element, 'registry', v);
+    }
+    set validateGate(v) {
+        assign(this.element, 'validateGate', v);
+    }
+    /** Label attributes beat the i18n catalog; unset = t('next')/t('submit')/t('back'). */
+    set nextLabel(v) {
+        assign(this.element, 'nextLabel', v);
+    }
+    set submitLabel(v) {
+        assign(this.element, 'submitLabel', v);
+    }
+    set backLabel(v) {
+        assign(this.element, 'backLabel', v);
+    }
+    set showBack(v) {
+        assign(this.element, 'showBack', v);
+    }
+    /** Feature-flag values (spec 01 §12): flag-off steps/fields/rules vanish. */
+    set flags(v) {
+        assign(this.element, 'flags', v);
+    }
+    /** Render a <baht-steps> progress indicator above the current form. */
+    set showSteps(v) {
+        assign(this.element, 'showSteps', v);
+    }
+    /** 'default' horizontal markers, or 'sidebar' vertical nav list — forwarded to <baht-steps>. */
+    set stepsVariant(v) {
+        assign(this.element, 'stepsVariant', v);
+    }
+    constructor() {
+        /** The element itself, for its methods. */
+        this.element = hostElement();
+        /** Any value changed. */
+        this.bahtDataChange = output();
+        /** Moved forward to `form_name`. */
+        this.bahtNext = output();
+        /** The visible step changed. */
+        this.bahtStepChange = output();
+        /** Next resolved to no visible step. */
+        this.bahtNavBlocked = output();
+        /** The last step was submitted. */
+        this.bahtSubmit = output();
+        /** The workflow ended. */
+        this.bahtComplete = output();
+        /** An approval step was approved. */
+        this.bahtApprove = output();
+        /** An approval step was rejected. */
+        this.bahtReject = output();
+        relay(this.element, 'baht-data-change', this.bahtDataChange);
+        relay(this.element, 'baht-next', this.bahtNext);
+        relay(this.element, 'baht-step-change', this.bahtStepChange);
+        relay(this.element, 'baht-nav-blocked', this.bahtNavBlocked);
+        relay(this.element, 'baht-submit', this.bahtSubmit);
+        relay(this.element, 'baht-complete', this.bahtComplete);
+        relay(this.element, 'baht-approve', this.bahtApprove);
+        relay(this.element, 'baht-reject', this.bahtReject);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtWorkflowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "22.2.5", type: BahtWorkflowDirective, isStandalone: true, selector: "baht-workflow", inputs: { workflow: "workflow", value: "value", registry: "registry", validateGate: ["validateGate", "validateGate", booleanAttribute], nextLabel: "nextLabel", submitLabel: "submitLabel", backLabel: "backLabel", showBack: ["showBack", "showBack", booleanAttribute], flags: "flags", showSteps: ["showSteps", "showSteps", booleanAttribute], stepsVariant: "stepsVariant" }, outputs: { bahtDataChange: "bahtDataChange", bahtNext: "bahtNext", bahtStepChange: "bahtStepChange", bahtNavBlocked: "bahtNavBlocked", bahtSubmit: "bahtSubmit", bahtComplete: "bahtComplete", bahtApprove: "bahtApprove", bahtReject: "bahtReject" }, exportAs: ["bahtWorkflow"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.5", ngImport: i0, type: BahtWorkflowDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'baht-workflow', exportAs: 'bahtWorkflow' }]
+        }], ctorParameters: () => [], propDecorators: { workflow: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], registry: [{
+                type: Input
+            }], validateGate: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], nextLabel: [{
+                type: Input
+            }], submitLabel: [{
+                type: Input
+            }], backLabel: [{
+                type: Input
+            }], showBack: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], flags: [{
+                type: Input
+            }], showSteps: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], stepsVariant: [{
+                type: Input
+            }], bahtDataChange: [{ type: i0.Output, args: ["bahtDataChange"] }], bahtNext: [{ type: i0.Output, args: ["bahtNext"] }], bahtStepChange: [{ type: i0.Output, args: ["bahtStepChange"] }], bahtNavBlocked: [{ type: i0.Output, args: ["bahtNavBlocked"] }], bahtSubmit: [{ type: i0.Output, args: ["bahtSubmit"] }], bahtComplete: [{ type: i0.Output, args: ["bahtComplete"] }], bahtApprove: [{ type: i0.Output, args: ["bahtApprove"] }], bahtReject: [{ type: i0.Output, args: ["bahtReject"] }] } });
+/** Every directive: `imports: [BAHT_UI]` in a standalone component. */
+export const BAHT_UI = [
+    BahtAccordionDirective,
+    BahtAlertDirective,
+    BahtAppShellDirective,
+    BahtApprovalChainDirective,
+    BahtAvatarDirective,
+    BahtBadgeDirective,
+    BahtBarChartDirective,
+    BahtBreadcrumbsDirective,
+    BahtButtonDirective,
+    BahtCardDirective,
+    BahtCatalogCardDirective,
+    BahtCheckboxDirective,
+    BahtCodeDirective,
+    BahtColumnPickerDirective,
+    BahtCommentsDirective,
+    BahtCurrencyDirective,
+    BahtDatepickerDirective,
+    BahtDonutChartDirective,
+    BahtEditTableDirective,
+    BahtEmptyStateDirective,
+    BahtErrorStateDirective,
+    BahtFieldsetDirective,
+    BahtFileDirective,
+    BahtFilterDirective,
+    BahtFilterBuilderDirective,
+    BahtFormDirective,
+    BahtHeatmapDirective,
+    BahtInputDirective,
+    BahtKeyvalueEditorDirective,
+    BahtLineChartDirective,
+    BahtLinkDirective,
+    BahtListDirective,
+    BahtLoadingOverlayDirective,
+    BahtMarkdownDirective,
+    BahtMarkdownViewDirective,
+    BahtMenuDirective,
+    BahtMeterDirective,
+    BahtModalDirective,
+    BahtMultiselectDirective,
+    BahtNotificationBellDirective,
+    BahtNumberDirective,
+    BahtOrderBoxDirective,
+    BahtOtpDirective,
+    BahtPageHeaderDirective,
+    BahtPaginationDirective,
+    BahtPopoverDirective,
+    BahtProgressDirective,
+    BahtProgressRingDirective,
+    BahtRadioDirective,
+    BahtRangeDirective,
+    BahtRatingDirective,
+    BahtRecordBarDirective,
+    BahtReferenceDialogDirective,
+    BahtReferencePickerDirective,
+    BahtRepeaterDirective,
+    BahtRuleBuilderDirective,
+    BahtSavedFiltersDirective,
+    BahtSectionDirective,
+    BahtSelectDirective,
+    BahtSkeletonDirective,
+    BahtSparklineDirective,
+    BahtSpinnerDirective,
+    BahtSplitButtonDirective,
+    BahtStatDirective,
+    BahtStatChartDirective,
+    BahtStepsDirective,
+    BahtSwipeRowDirective,
+    BahtTableDirective,
+    BahtTabsDirective,
+    BahtTagsDirective,
+    BahtTextDirective,
+    BahtTextareaDirective,
+    BahtThemeToggleDirective,
+    BahtTimelineDirective,
+    BahtToastDirective,
+    BahtToggleDirective,
+    BahtTooltipDirective,
+    BahtTypeaheadDirective,
+    BahtUploadDirective,
+    BahtWizardDirective,
+    BahtWorkflowDirective,
+];