@aparte/angular 0.10.0 → 0.12.0

package/dist/generated/element.directives.d.ts

@@ -0,0 +1,329 @@
+/**
+ * A typed Angular surface for every element this package defines.
+ *
+ * Generated, and that is the point: a hand-written directive is a parallel structure over
+ * the manifest with nothing watching it, so an attribute added to an element would be
+ * typed in React, Vue and Svelte — which derive from the registry — and silently missing
+ * here. That happened, which is why this file is generated now.
+ *
+ * Outputs emit the event's DETAIL, not the `CustomEvent`, because
+ * `(selectChange)="pick($event.value)"` is the Angular idiom. Reach the event itself with
+ * a plain host listener when you need `stopPropagation`.
+ */
+import { ElementRef, EventEmitter } from '@angular/core';
+import type { AparteActionClickEventDetail, AparteActionEventDetail, AparteAttachmentPreviewEventDetail, AparteBranchNavigateEventDetail, AparteComposerChangeEventDetail, AparteConversationArchiveDetail, AparteConversationDeleteDetail, AparteConversationSelectDetail, AparteEditEventDetail, AparteFeedbackEventDetail, AparteMessageInfoEventDetail, AparteOptgroupToggleEventDetail, ApartePathChangedEventDetail, AparteRetryEventDetail, AparteSegmentUpdateEventDetail, AparteSelectChangeDetail, AparteSendEventDetail } from '@aparte/core';
+import * as i0 from "@angular/core";
+/**
+ * Writes one declared attribute onto the host element.
+ *
+ * `applyElementProps` is core's own rule, reused rather than reimplemented: a primitive
+ * goes through `setAttribute`, `true` becomes the empty presence attribute,
+ * `false`/`null`/`undefined` remove it, and only a value an attribute cannot carry is
+ * handed over as a property.
+ */
+declare abstract class AparteElementBase {
+    protected readonly host: ElementRef<any>;
+    protected write(name: string, value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteElementBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteElementBase, never, never, {}, {}, never, never, true, never>;
+}
+/** `<aparte-chat-bubble>` — One message: plain content or a list of rich segments, in light DOM. */
+export declare class AparteChatBubbleDirective extends AparteElementBase {
+    /** `user` / `assistant` / `system`; what the CSS keys off. */
+    set messageRole(v: string | undefined);
+    /** Plain text content, for a bubble with no segments. */
+    set content(v: string | undefined);
+    /** Epoch milliseconds OR a date string: `_updateTimestamp` accepts either and only coerces when the value is numeric. */
+    set timestamp(v: number | string | undefined);
+    /** How streaming and the action bar address this bubble. */
+    set messageId(v: string | undefined);
+    /** Hides the action bar and shows the caret while a reply is in flight. */
+    set streaming(v: boolean);
+    /** The display name in the header. */
+    set name(v: string | undefined);
+    /** An attached image was clicked, asking the app to open it full-size. */
+    readonly attachmentPreview: EventEmitter<AparteAttachmentPreviewEventDetail>;
+    /** A custom action-bar button was pressed. */
+    readonly action: EventEmitter<AparteActionEventDetail>;
+    /** Retry was pressed; the host forks the turn. */
+    readonly retry: EventEmitter<AparteRetryEventDetail>;
+    /** Thumbs up or down. */
+    readonly feedback: EventEmitter<AparteFeedbackEventDetail>;
+    /** The info affordance was pressed. */
+    readonly messageInfo: EventEmitter<AparteMessageInfoEventDetail>;
+    /** An edit was saved. */
+    readonly edit: EventEmitter<AparteEditEventDetail>;
+    /** The `‹1/2›` picker moved between sibling versions. */
+    readonly branchNavigate: EventEmitter<AparteBranchNavigateEventDetail>;
+    protected onAttachmentPreview(e: CustomEvent<AparteAttachmentPreviewEventDetail>): void;
+    protected onAction(e: CustomEvent<AparteActionEventDetail>): void;
+    protected onRetry(e: CustomEvent<AparteRetryEventDetail>): void;
+    protected onFeedback(e: CustomEvent<AparteFeedbackEventDetail>): void;
+    protected onMessageInfo(e: CustomEvent<AparteMessageInfoEventDetail>): void;
+    protected onEdit(e: CustomEvent<AparteEditEventDetail>): void;
+    protected onBranchNavigate(e: CustomEvent<AparteBranchNavigateEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteChatBubbleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteChatBubbleDirective, "aparte-chat-bubble", never, { "messageRole": { "alias": "messageRole"; "required": false; }; "content": { "alias": "content"; "required": false; }; "timestamp": { "alias": "timestamp"; "required": false; }; "messageId": { "alias": "messageId"; "required": false; }; "streaming": { "alias": "streaming"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "attachmentPreview": "attachmentPreview"; "action": "action"; "retry": "retry"; "feedback": "feedback"; "messageInfo": "messageInfo"; "edit": "edit"; "branchNavigate": "branchNavigate"; }, never, never, true, never>;
+    static ngAcceptInputType_streaming: unknown;
+}
+/** `<aparte-chat-status>` — A standalone status line — a light-DOM typing indicator the APP owns. Core never turns it on by itself, so it can never compete with the bubble's own waiting state. */
+export declare class AparteChatStatusDirective extends AparteElementBase {
+    /** Shows or hides the indicator. */
+    set visible(v: boolean);
+    /** The line to show. Defaults to the locale's typing string. */
+    set text(v: string | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteChatStatusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteChatStatusDirective, "aparte-chat-status", never, { "visible": { "alias": "visible"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_visible: unknown;
+}
+/** `<aparte-chat-viewport>` — The transcript surface: a light-DOM container with sticky scrolling, token streaming and segment-aware rendering. */
+export declare class AparteChatViewportDirective extends AparteElementBase {
+    /** How close to the bottom still counts as "at the bottom". */
+    set scrollThreshold(v: number);
+    /** Caps how many bubbles stay in the DOM; older ones are released. */
+    set maxRenderedBubbles(v: number);
+    /** DEPRECATED. It used to evict messages from the model; it now only caps rendered bubbles, which is what `max-rendered-bubbles` says. For real history retention configure the conversation manager instead. */
+    set maxMessages(v: number);
+    /** The wrapper's explicit hands-off signal: set it and this element composes none of its own children, because the framework owns them. All four wrappers set it; it was read by this element and declared by nothing until now. */
+    set frameworkManaged(v: boolean);
+    /** A segment grew or settled during a stream. */
+    readonly segmentUpdate: EventEmitter<AparteSegmentUpdateEventDetail>;
+    /** `clearAll()` finished emptying the transcript. No detail. */
+    readonly resetDone: EventEmitter<void>;
+    /** The active branch path changed, after a retry fork or a navigation. Features: - Smart Scroll: Sticks to bottom when user is at bottom, stops on manual scroll up - appendToken(): For simple content streaming - appendToSegment(): For segment-aware streaming (thinking, code, etc.) - Internal message registry for memory management */
+    readonly pathChanged: EventEmitter<ApartePathChangedEventDetail>;
+    protected onSegmentUpdate(e: CustomEvent<AparteSegmentUpdateEventDetail>): void;
+    protected onResetDone(): void;
+    protected onPathChanged(e: CustomEvent<ApartePathChangedEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteChatViewportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteChatViewportDirective, "aparte-chat-viewport", never, { "scrollThreshold": { "alias": "scrollThreshold"; "required": false; }; "maxRenderedBubbles": { "alias": "maxRenderedBubbles"; "required": false; }; "maxMessages": { "alias": "maxMessages"; "required": false; }; "frameworkManaged": { "alias": "frameworkManaged"; "required": false; }; }, { "segmentUpdate": "segmentUpdate"; "resetDone": "resetDone"; "pathChanged": "pathChanged"; }, never, never, true, never>;
+    static ngAcceptInputType_scrollThreshold: unknown;
+    static ngAcceptInputType_maxRenderedBubbles: unknown;
+    static ngAcceptInputType_maxMessages: unknown;
+    static ngAcceptInputType_frameworkManaged: unknown;
+}
+/** `<aparte-composer>` — The root context for every `aparte-composer-*` primitive. It imposes no visual layout — the consumer owns the structure — and holds the shared state the parts read: the value, the streaming flag, pending attachments, the panel slot. */
+export declare class AparteComposerDirective extends AparteElementBase {
+    /** Forwarded to `<aparte-composer-input>` through the internal bus. */
+    set placeholder(v: string | undefined);
+    /** Disables the whole composer, every part included. */
+    set disabled(v: boolean);
+    /** The id of the `<aparte-chat>` this composer drives. */
+    set target(v: string | undefined);
+    /** Enter sends and Shift+Enter breaks the line (the default); set it to the string `"false"` to swap them. Read lazily by the `submitOnEnter` getter rather than observed, which is why it was missing from the manifest — and so from every typed surface — while all four wrappers wrote it. */
+    set submitOnEnter(v: boolean);
+    /** A message was submitted: the text, its attachments and the target. */
+    readonly send: EventEmitter<AparteSendEventDetail>;
+    /** The stop button was pressed. No detail; the two window events below carry the target. */
+    readonly cancel: EventEmitter<void>;
+    /** Any of value / streaming / disabled / attachments / panel changed, folded into one event. */
+    readonly composerChange: EventEmitter<AparteComposerChangeEventDetail>;
+    protected onSend(e: CustomEvent<AparteSendEventDetail>): void;
+    protected onCancel(): void;
+    protected onComposerChange(e: CustomEvent<AparteComposerChangeEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerDirective, "aparte-composer", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "target": { "alias": "target"; "required": false; }; "submitOnEnter": { "alias": "submitOnEnter"; "required": false; }; }, { "send": "send"; "cancel": "cancel"; "composerChange": "composerChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_submitOnEnter: unknown;
+}
+/** `<aparte-composer-action>` — Generic action button primitive for <aparte-composer>. */
+export declare class AparteComposerActionDirective extends AparteElementBase {
+    /** Icon key for aparteGlobalConfig.getIcon(), or raw SVG/HTML starting with `<` */
+    set icon(v: string | undefined);
+    /** Accessible label (also used as tooltip) */
+    set label(v: string | undefined);
+    /** Disables the button */
+    set disabled(v: boolean);
+    /** Identifies WHICH button fired; carried as `AparteActionClickEventDetail.actionId`. Read lazily at dispatch time rather than observed, so the manifest never recorded it — leaving the only way to tell two custom composer buttons apart absent from the typed surface. */
+    set actionId(v: string | undefined);
+    /** Bubbles up when the button is clicked, carrying which button it was and the composer it belongs to. The type argument is not decoration: a BARE `@fires` records `CustomEvent` with no argument, and the bindings generator then emits `EventEmitter<void>` with a listener that drops `$event` — so an Angular consumer with two custom buttons could not tell which one fired. detail: { actionId: string, composer: AparteComposer | null } */
+    readonly actionClick: EventEmitter<AparteActionClickEventDetail>;
+    protected onActionClick(e: CustomEvent<AparteActionClickEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerActionDirective, "aparte-composer-action", never, { "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "actionId": { "alias": "actionId"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+/** `<aparte-composer-add-attachment>` — File picker button for <aparte-composer>. */
+export declare class AparteComposerAddAttachmentDirective extends AparteElementBase {
+    /** MIME types / extensions passed to the file input (e.g. "image/*,.pdf") */
+    set accept(v: string | undefined);
+    /** Allow multiple file selection (default: true) */
+    set multiple(v: boolean);
+    /** Greys out the picker and ignores drops. */
+    set disabled(v: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerAddAttachmentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerAddAttachmentDirective, "aparte-composer-add-attachment", never, { "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+/** `<aparte-composer-attachments>` — Renders a square thumbnail tile for each file attached to the root composer. */
+export declare class AparteComposerAttachmentsDirective {
+    /** An attached image was clicked; the app opens it full-size, and only if it declared `attachmentPreview`. */
+    readonly attachmentPreview: EventEmitter<AparteAttachmentPreviewEventDetail>;
+    protected onAttachmentPreview(e: CustomEvent<AparteAttachmentPreviewEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerAttachmentsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerAttachmentsDirective, "aparte-composer-attachments", never, {}, { "attachmentPreview": "attachmentPreview"; }, never, never, true, never>;
+}
+/** `<aparte-composer-cancel>` — Cancel/stop streaming button primitive for <aparte-composer>. */
+/**
+ * No member at all: this element observes nothing and dispatches nothing, so the
+ * directive exists only to CLAIM THE TAG — which is what spares a consuming component
+ * `CUSTOM_ELEMENTS_SCHEMA`, a switch that turns checking off for every unknown tag in
+ * the file rather than just this one.
+ */
+export declare class AparteComposerCancelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerCancelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerCancelDirective, "aparte-composer-cancel", never, {}, {}, never, never, true, never>;
+}
+/** `<aparte-composer-input>` — Contenteditable text input primitive. */
+export declare class AparteComposerInputDirective extends AparteElementBase {
+    /** Placeholder text (fallback: reads from aparte-composer) */
+    set placeholder(v: string | undefined);
+    /** Max height in px before scroll (default: 200) */
+    set maxHeight(v: number);
+    /** Min height in px. When omitted, the stylesheet's min-height governs (44px in aparte.css) — so themes can resize the editor in pure CSS without being fought by an inline height. */
+    set minHeight(v: number);
+    /** Makes the field non-editable; the composer's own `disabled` also reaches it. */
+    set disabled(v: boolean);
+    /** Enter was pressed with content. No detail; the composer reads its own value. Behaviour: Enter submits (calls root.submit()), Shift+Enter inserts newline. Auto-expands up to max-height. Paste strips HTML, handles image paste. */
+    readonly composerSubmit: EventEmitter<void>;
+    protected onComposerSubmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerInputDirective, "aparte-composer-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "composerSubmit": "composerSubmit"; }, never, never, true, never>;
+    static ngAcceptInputType_maxHeight: unknown;
+    static ngAcceptInputType_minHeight: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+/** `<aparte-composer-send>` — Submit button primitive for <aparte-composer>. */
+/**
+ * No member at all: this element observes nothing and dispatches nothing, so the
+ * directive exists only to CLAIM THE TAG — which is what spares a consuming component
+ * `CUSTOM_ELEMENTS_SCHEMA`, a switch that turns checking off for every unknown tag in
+ * the file rather than just this one.
+ */
+export declare class AparteComposerSendDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerSendDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerSendDirective, "aparte-composer-send", never, {}, {}, never, never, true, never>;
+}
+/** `<aparte-composer-toolbar>` — The composer's bottom row — the strip a mode picker, a model selector or a token counter belongs in, rather than a bar of your own floating below the chat. Purely structural: it lays its children out in a row and gets out of the way. */
+/**
+ * No member at all: this element observes nothing and dispatches nothing, so the
+ * directive exists only to CLAIM THE TAG — which is what spares a consuming component
+ * `CUSTOM_ELEMENTS_SCHEMA`, a switch that turns checking off for every unknown tag in
+ * the file rather than just this one.
+ */
+export declare class AparteComposerToolbarDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteComposerToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteComposerToolbarDirective, "aparte-composer-toolbar", never, {}, {}, never, never, true, never>;
+}
+/** `<aparte-conversation-list>` — Conversation-history sidebar — a framework-agnostic web component. The host sets the `conversations` JS property and the `active-id` attribute; this renders the list and fires the user's intent, never acting on it itself. */
+export declare class AparteConversationListDirective extends AparteElementBase {
+    /** The id of the conversation to render as selected. */
+    set activeId(v: string | undefined);
+    /** A row was activated; the host loads that conversation. */
+    readonly selectConversation: EventEmitter<AparteConversationSelectDetail>;
+    /** The delete action was pressed. Nothing is removed here. */
+    readonly deleteConversation: EventEmitter<AparteConversationDeleteDetail>;
+    /** The archive action was pressed on a live conversation. */
+    readonly archiveConversation: EventEmitter<AparteConversationArchiveDetail>;
+    /** The same action on an already-archived one; same detail shape, opposite intent. */
+    readonly unarchiveConversation: EventEmitter<AparteConversationArchiveDetail>;
+    protected onSelectConversation(e: CustomEvent<AparteConversationSelectDetail>): void;
+    protected onDeleteConversation(e: CustomEvent<AparteConversationDeleteDetail>): void;
+    protected onArchiveConversation(e: CustomEvent<AparteConversationArchiveDetail>): void;
+    protected onUnarchiveConversation(e: CustomEvent<AparteConversationArchiveDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteConversationListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteConversationListDirective, "aparte-conversation-list", never, { "activeId": { "alias": "activeId"; "required": false; }; }, { "selectConversation": "selectConversation"; "deleteConversation": "deleteConversation"; "archiveConversation": "archiveConversation"; "unarchiveConversation": "unarchiveConversation"; }, never, never, true, never>;
+}
+/** `<aparte-elicitation>` — The default presenter for a request to the human. It renders nothing itself: it registers as the presenter for the config governing its subtree, and mounts a panel inside the nearest `<aparte-composer>` when something asks — a tool handler calling `requestUserInput`, or core's own approval gate. */
+/**
+ * No member at all: this element observes nothing and dispatches nothing, so the
+ * directive exists only to CLAIM THE TAG — which is what spares a consuming component
+ * `CUSTOM_ELEMENTS_SCHEMA`, a switch that turns checking off for every unknown tag in
+ * the file rather than just this one.
+ */
+export declare class AparteElicitationDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteElicitationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteElicitationDirective, "aparte-elicitation", never, {}, {}, never, never, true, never>;
+}
+/** `<aparte-optgroup>` — AparteOptgroup */
+export declare class AparteOptgroupDirective extends AparteElementBase {
+    /** Group label */
+    set label(v: string | undefined);
+    /** Allow collapse/expand */
+    set collapsible(v: boolean);
+    /** Collapsed state */
+    set collapsed(v: boolean);
+    /** Shows a spinner in place of the group's options. */
+    set loading(v: boolean);
+    /** The group was collapsed or expanded. */
+    readonly optgroupToggle: EventEmitter<AparteOptgroupToggleEventDetail>;
+    protected onOptgroupToggle(e: CustomEvent<AparteOptgroupToggleEventDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteOptgroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteOptgroupDirective, "aparte-optgroup", never, { "label": { "alias": "label"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "optgroupToggle": "optgroupToggle"; }, never, never, true, never>;
+    static ngAcceptInputType_collapsible: unknown;
+    static ngAcceptInputType_collapsed: unknown;
+    static ngAcceptInputType_loading: unknown;
+}
+/** `<aparte-option>` — AparteOption */
+export declare class AparteOptionDirective extends AparteElementBase {
+    /** Option value */
+    set value(v: string | undefined);
+    /** Disabled state */
+    set disabled(v: boolean);
+    /** Selected state */
+    set selected(v: boolean);
+    /** Free-form status the host sets; styled, never read by core. */
+    set dataStatus(v: string | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteOptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteOptionDirective, "aparte-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "dataStatus": { "alias": "dataStatus"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_selected: unknown;
+}
+/** `<aparte-progress-spinner>` — AparteProgressSpinner */
+export declare class AparteProgressSpinnerDirective extends AparteElementBase {
+    /** Progress percentage 0–100 (omit for indeterminate) */
+    set value(v: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteProgressSpinnerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteProgressSpinnerDirective, "aparte-progress-spinner", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_value: unknown;
+}
+/** `<aparte-select>` — Dropdown select for aparté — a vanilla web component with optional grouping, a search filter and a keyboard-driven listbox. */
+export declare class AparteSelectDirective extends AparteElementBase {
+    /** The selected option's value. */
+    set value(v: string | undefined);
+    /** Shown while nothing is selected. */
+    set placeholder(v: string | undefined);
+    /** Blocks opening and selection. */
+    set disabled(v: boolean);
+    /** Renders `<aparte-optgroup>` children as collapsible groups. */
+    set grouped(v: boolean);
+    /** Adds a filter field above the options. */
+    set searchable(v: boolean);
+    /** Reflects (and controls) whether the dropdown is open. */
+    set open(v: boolean);
+    /** The dropdown opened. No detail. */
+    readonly selectOpen: EventEmitter<void>;
+    /** The dropdown closed. No detail. */
+    readonly selectClose: EventEmitter<void>;
+    /** The selection changed; carries the new value, its label and the previous value. */
+    readonly selectChange: EventEmitter<AparteSelectChangeDetail>;
+    protected onSelectOpen(): void;
+    protected onSelectClose(): void;
+    protected onSelectChange(e: CustomEvent<AparteSelectChangeDetail>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AparteSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteSelectDirective, "aparte-select", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "selectOpen": "selectOpen"; "selectClose": "selectClose"; "selectChange": "selectChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_grouped: unknown;
+    static ngAcceptInputType_searchable: unknown;
+    static ngAcceptInputType_open: unknown;
+}
+/**
+ * Every element directive, for one import in a standalone component.
+ *
+ * ```ts
+ * @Component({ imports: [...APARTE_ELEMENT_DIRECTIVES], template: `…` })
+ * ```
+ */
+export declare const APARTE_ELEMENT_DIRECTIVES: readonly [typeof AparteChatBubbleDirective, typeof AparteChatStatusDirective, typeof AparteChatViewportDirective, typeof AparteComposerDirective, typeof AparteComposerActionDirective, typeof AparteComposerAddAttachmentDirective, typeof AparteComposerAttachmentsDirective, typeof AparteComposerCancelDirective, typeof AparteComposerInputDirective, typeof AparteComposerSendDirective, typeof AparteComposerToolbarDirective, typeof AparteConversationListDirective, typeof AparteElicitationDirective, typeof AparteOptgroupDirective, typeof AparteOptionDirective, typeof AparteProgressSpinnerDirective, typeof AparteSelectDirective];
+export {};

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export type { ProvideAparteOptions, ApartePluginLoader } from './lib/provide-apa
 export { AparteChatComponent } from './lib/aparte-chat.component';
 export { AparteUiComponent } from './lib/aparte-ui.component';
 export type { AparteUiHandle } from './lib/aparte-ui.component';
+export { APARTE_ELEMENT_DIRECTIVES, AparteChatViewportDirective, AparteChatBubbleDirective, AparteChatStatusDirective, AparteComposerDirective, AparteComposerInputDirective, AparteComposerActionDirective, AparteComposerAddAttachmentDirective, AparteComposerAttachmentsDirective, AparteComposerSendDirective, AparteComposerCancelDirective, AparteComposerToolbarDirective, AparteSelectDirective, AparteOptionDirective, AparteOptgroupDirective, AparteConversationListDirective, AparteProgressSpinnerDirective, AparteElicitationDirective, } from './generated/element.directives';
 export { AparteAiService, APARTE_CLIENT_OPTIONS } from './lib/aparte-ai.service';
 export { ConversationManagerService } from './lib/conversation-manager.service';
 export type { AparteMessage, AparteSendEventDetail, AparteActionEventDetail, AparteSegment, AparteTextSegment, AparteCodeSegment, AparteThinkingSegment, AparteChatImperativeApi, } from '@aparte/core';

package/dist/lib/aparte-ui.component.d.ts

@@ -20,6 +20,11 @@ export interface AparteUiHandle {
  * its own once the definition arrives, which is what makes `provideAparte`'s lazy
  * `plugins` loaders work.
  *
+ * A PLUGIN's event is not in the default forward list — that default is core's, and a
+ * third-party plugin's author cannot add to it, so listing ours would privilege our
+ * packages over theirs. Name it in `events` and it arrives; leave it out and the handler
+ * silently never fires, which is what this example used to do.
+ *
  * @example
  * ```html
  * <aparte-ui
@@ -29,6 +34,7 @@ export interface AparteUiHandle {
  *     '--glow-opacity': '1',
  *     '--glow-speed': '4s'
  *   }"
+ *   [events]="['aparte-model-change']"
  *   (elementEvent)="onEvent($event)"
  * />
  * ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aparte/angular",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Angular 19 wrapper for aparté — an ergonomic <aparte-chat> component plus services over the framework-agnostic web components.",
   "type": "module",
   "sideEffects": false,
@@ -45,7 +45,7 @@
     "typescript": "^5.4.0",
     "vite": "^6.0.0",
     "zone.js": "~0.15.0",
-    "@aparte/core": "0.10.0"
+    "@aparte/core": "0.12.0"
   },
   "keywords": [
     "angular",
@@ -69,6 +69,7 @@
     "typecheck:tests": "tsc -p tsconfig.spec.json --noEmit",
     "test": "vitest",
     "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "gen": "node ../../../scripts/gen-element-bindings.mjs packages/core --angular packages/wrappers/angular/src/generated"
   }
 }