/**
 * 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, AparteCompactEventDetail, AparteComposerChangeEventDetail, AparteContextThresholdEventDetail, AparteConversationArchiveDetail, AparteConversationDeleteDetail, AparteConversationPinDetail, AparteConversationRenameDetail, AparteConversationSelectDetail, AparteEditEventDetail, AparteFeedbackEventDetail, AparteLinkClickEventDetail, AparteMessageInfoEventDetail, AparteOptgroupToggleEventDetail, ApartePathChangedEventDetail, AparteRetryEventDetail, AparteScrollRailJumpDetail, AparteSegmentUpdateEventDetail, AparteSelectChangeDetail, AparteSendEventDetail, AparteSidebarToggleDetail, AparteSplitResizeDetail, AparteSuggestionEventDetail } 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 {
    /** The message role, `user` or `assistant` — the one channel for it, and what the CSS keys off. (`role` is ARIA's attribute; this element sets it to `article` itself and no longer reads a message role from it.) */
    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>;
    /** A link in the message body is about to be followed. Cancelable: `preventDefault()` keeps the browser from navigating, so a host can route the link itself. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-link-click)="$event.preventDefault()". */
    readonly linkClick: EventEmitter<AparteLinkClickEventDetail>;
    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;
    protected onLinkClick(e: CustomEvent<AparteLinkClickEventDetail>): 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"; "linkClick": "linkClick"; }, never, never, true, never>;
    static ngAcceptInputType_streaming: unknown;
}
/** `<aparte-chat-status>` — A standalone status line — a light-DOM indicator the APP owns. Nothing in core turns it on: the framework host only ever flips it back OFF (on the first streamed token), and the four wrappers render one inside the viewport driven by their own `isTyping` prop. */
export declare class AparteChatStatusDirective extends AparteElementBase {
    /** Shows or hides the indicator. */
    set visible(v: boolean);
    /** The line to show. Absent, the line is dots-only and the accessible name falls back to the literal `Typing` (not the locale's 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);
    /** The transcript is on its way: a conversation was chosen and its messages are being fetched. The element draws two skeleton turns, marks its scroll surface `aria-busy` and names the wait for a screen reader; `aparte-chat[center-empty]` does not count a loading viewport as empty. Set by `AparteConversationController` through its binding, or by hand from a loop of your own (`setLoading(true)`). */
    set loading(v: boolean);
    /** The wrapper's explicit hands-off signal: set it and this element builds no wrapper of its own and relocates none of the nodes the FRAMEWORK renders into it, because the framework owns them. Not "none of its children": core's own scroll-to-bottom button is re-appended whenever it stops being last, and that path runs in this mode only. All four wrappers set it. */
    set frameworkManaged(v: boolean);
    /** Reflected BY the element while a turn streams: the transcript is read-only meanwhile, and every bubble inside reads it (at connect, and when it changes). The vanilla path derives it from the repository; a framework host sets it through `setTranscriptBusy()`. Read-only from the outside. */
    set dataBusy(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. */
    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; }; "loading": { "alias": "loading"; "required": false; }; "frameworkManaged": { "alias": "frameworkManaged"; "required": false; }; "dataBusy": { "alias": "dataBusy"; "required": false; }; }, { "segmentUpdate": "segmentUpdate"; "resetDone": "resetDone"; "pathChanged": "pathChanged"; }, never, never, true, never>;
    static ngAcceptInputType_scrollThreshold: unknown;
    static ngAcceptInputType_maxRenderedBubbles: unknown;
    static ngAcceptInputType_loading: unknown;
    static ngAcceptInputType_frameworkManaged: unknown;
    static ngAcceptInputType_dataBusy: 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, whether a panel is up. */
export declare class AparteComposerDirective extends AparteElementBase {
    /** Fallback placeholder for `<aparte-composer-input>`, which reads it off this element when it carries none of its own. Changing it here reaches the inputs already on the page too. */
    set placeholder(v: string | undefined);
    /** Disables the composer's own controls — the input, send, add-attachment and `<aparte-composer-action>` buttons each read it. What you put in the toolbar is yours to disable. */
    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);
    /** Reflected BY the element while a panel (an elicitation, an approval) is mounted inside it; the shipped stylesheet keys off it. Read-only. */
    set dataPanelActive(v: boolean);
    /** Reflected BY the element while a panel is active: what the send button does meanwhile (`'none'` removes it — through this attribute, not by reaching into the button). Read-only. */
    set dataPanelMode(v: string | undefined);
    /** Reflected BY the element when `requireModelSelection` is on and no model is selected: sending is blocked and the shipped stylesheet greys the composer. Read-only. */
    set dataModelGated(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; }; "dataPanelActive": { "alias": "dataPanelActive"; "required": false; }; "dataPanelMode": { "alias": "dataPanelMode"; "required": false; }; "dataModelGated": { "alias": "dataModelGated"; "required": false; }; }, { "send": "send"; "cancel": "cancel"; "composerChange": "composerChange"; }, never, never, true, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_submitOnEnter: unknown;
    static ngAcceptInputType_dataPanelActive: unknown;
    static ngAcceptInputType_dataModelGated: 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 `<`. A key core's glyph set does not hold renders AS TEXT (`icon="star"` draws the word *star*), so bring your own set through `setIconProvider` or pass the SVG. */
    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 changing it takes effect on the next click. */
    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. Drops are gated by the composer root's `disabled`, not by this one. */
    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);
    /** A submitting Enter was pressed with no `<aparte-composer>` ancestor to submit to; with one it calls `root.submit()` and dispatches nothing. No detail — the host that placed this primitive reads `getValue()`. */
    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-context>` — A gauge of the model's context window: how much of it the conversation uses. */
export declare class AparteContextDirective extends AparteElementBase {
    /** The context window, in tokens. Overrides the current model's `contextWindow`. */
    set window(v: number);
    /** Fraction of the window at which the level turns `warn`. Default `0.75`. */
    set warn(v: number);
    /** Fraction at which it turns `danger`. Default `0.9`. */
    set danger(v: number);
    /** The id of the `<aparte-chat>` to watch, when the element is not under it. */
    set target(v: string | undefined);
    /** `bar` (default) or `ring`: a progress bar with the reading beside it, or a ring with the percentage. */
    set variant(v: string | undefined);
    /** Dispatch `aparte-compact` on reaching `danger` (once per crossing). */
    set autoCompact(v: boolean);
    /** Reflected BY the element: `ok`, `warn` or `danger`. Read-only. */
    set dataLevel(v: string | undefined);
    /** Reflected BY the element while it has nothing to show. Read-only. */
    set dataEmpty(v: boolean);
    /** The level changed. Bubbles. */
    readonly contextThreshold: EventEmitter<AparteContextThresholdEventDetail>;
    /** Dispatched on `window` when `auto-compact` is set and the gauge first reaches `danger`: compact this target's transcript. Once per crossing, and only while the attribute is present. `@aparte/plugin-compaction` answers it; with no listener nothing happens. */
    readonly compact: EventEmitter<AparteCompactEventDetail>;
    protected onContextThreshold(e: CustomEvent<AparteContextThresholdEventDetail>): void;
    protected onCompact(e: CustomEvent<AparteCompactEventDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteContextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteContextDirective, "aparte-context", never, { "window": { "alias": "window"; "required": false; }; "warn": { "alias": "warn"; "required": false; }; "danger": { "alias": "danger"; "required": false; }; "target": { "alias": "target"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "autoCompact": { "alias": "autoCompact"; "required": false; }; "dataLevel": { "alias": "dataLevel"; "required": false; }; "dataEmpty": { "alias": "dataEmpty"; "required": false; }; }, { "contextThreshold": "contextThreshold"; "compact": "compact"; }, never, never, true, never>;
    static ngAcceptInputType_window: unknown;
    static ngAcceptInputType_warn: unknown;
    static ngAcceptInputType_danger: unknown;
    static ngAcceptInputType_autoCompact: unknown;
    static ngAcceptInputType_dataEmpty: unknown;
}
/** `<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 rows and fires the user's intent. Acting on it is the host's, unless `manage` hands the row menu's writes to the registered conversation manager. */
export declare class AparteConversationListDirective extends AparteElementBase {
    /** The id of the conversation to render as selected. */
    set activeId(v: string | undefined);
    /** Render the rows flat, in host order, with no date headings. */
    set flat(v: boolean);
    /** The list is on its way: six skeleton rows stand where the rows will be, the element is `aria-busy` and a visually hidden line names the wait. A list that is not there yet is not an empty list. Set it while your store answers, clear it when you assign `conversations`. */
    set loading(v: boolean);
    /** Let the list finish the gesture: rename, pin, unpin, archive, unarchive and delete are performed on the conversation manager registered with `setConversationManager()`, instead of leaving you six listeners to write. The event still fires first, and `preventDefault()` on it takes the gesture back. Off by default, and selecting stays yours either way. */
    set manage(v: boolean);
    /** A row's title was activated; the host loads that conversation. */
    readonly conversationSelect: EventEmitter<AparteConversationSelectDetail>;
    /** A rename was committed with a new, non-empty title. Cancelable: `preventDefault()` takes the gesture back from `manage`. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-rename)="$event.preventDefault()". */
    readonly conversationRename: EventEmitter<AparteConversationRenameDetail>;
    /** The pin item was chosen on an unpinned row. Cancelable: `preventDefault()` takes the gesture back from `manage`. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-pin)="$event.preventDefault()". */
    readonly conversationPin: EventEmitter<AparteConversationPinDetail>;
    /** The same item on a pinned row; same detail shape, opposite intent. Cancelable, like the rest. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-unpin)="$event.preventDefault()". */
    readonly conversationUnpin: EventEmitter<AparteConversationPinDetail>;
    /** The archive item was chosen on a live conversation. Cancelable: `preventDefault()` takes the gesture back from `manage`. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-archive)="$event.preventDefault()". */
    readonly conversationArchive: EventEmitter<AparteConversationArchiveDetail>;
    /** The same item on an already-archived one; same detail shape, opposite intent. Cancelable, like the rest. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-unarchive)="$event.preventDefault()". */
    readonly conversationUnarchive: EventEmitter<AparteConversationArchiveDetail>;
    /** The delete was confirmed. Cancelable: `preventDefault()` takes the gesture back from `manage`. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-conversation-delete)="$event.preventDefault()". */
    readonly conversationDelete: EventEmitter<AparteConversationDeleteDetail>;
    protected onConversationSelect(e: CustomEvent<AparteConversationSelectDetail>): void;
    protected onConversationRename(e: CustomEvent<AparteConversationRenameDetail>): void;
    protected onConversationPin(e: CustomEvent<AparteConversationPinDetail>): void;
    protected onConversationUnpin(e: CustomEvent<AparteConversationPinDetail>): void;
    protected onConversationArchive(e: CustomEvent<AparteConversationArchiveDetail>): void;
    protected onConversationUnarchive(e: CustomEvent<AparteConversationArchiveDetail>): void;
    protected onConversationDelete(e: CustomEvent<AparteConversationDeleteDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteConversationListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteConversationListDirective, "aparte-conversation-list", never, { "activeId": { "alias": "activeId"; "required": false; }; "flat": { "alias": "flat"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "manage": { "alias": "manage"; "required": false; }; }, { "conversationSelect": "conversationSelect"; "conversationRename": "conversationRename"; "conversationPin": "conversationPin"; "conversationUnpin": "conversationUnpin"; "conversationArchive": "conversationArchive"; "conversationUnarchive": "conversationUnarchive"; "conversationDelete": "conversationDelete"; }, never, never, true, never>;
    static ngAcceptInputType_flat: unknown;
    static ngAcceptInputType_loading: unknown;
    static ngAcceptInputType_manage: unknown;
}
/** `<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-icon>` — AparteIcon */
export declare class AparteIconDirective extends AparteElementBase {
    /** Which glyph to draw. One of the names `setIconProvider` accepts; an unknown name draws nothing rather than a broken-image box. */
    set name(v: string | undefined);
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteIconDirective, "aparte-icon", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, never, true, never>;
}
/** `<aparte-optgroup>` — AparteOptgroup */
export declare class AparteOptgroupDirective extends AparteElementBase {
    /** Group label */
    set label(v: string | undefined);
    /** Adds the chevron and the click handler to the header — so it needs a `label`, and it is read only when that header is first built. */
    set collapsible(v: boolean);
    /** Collapsed state */
    set collapsed(v: boolean);
    /** Appends a spinner row to the group; the options stay visible. */
    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-scroll-rail>` — A rail of ticks beside the transcript — one per turn — that shows where you are in a long conversation and jumps back to any message on a click. */
export declare class AparteScrollRailDirective extends AparteElementBase {
    /** The id of the `<aparte-chat>` to follow, when the element is not inside it. */
    set target(v: string | undefined);
    /** `user` (default): one tick per user turn. `message`: one per message. */
    set every(v: string | undefined);
    /** Reflected BY the element while it has fewer than two ticks. Read-only. */
    set dataEmpty(v: boolean);
    /** A tick was activated. Bubbles, cancelable: `preventDefault()` leaves the transcript where it is. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-scroll-rail-jump)="$event.preventDefault()". */
    readonly scrollRailJump: EventEmitter<AparteScrollRailJumpDetail>;
    protected onScrollRailJump(e: CustomEvent<AparteScrollRailJumpDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteScrollRailDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteScrollRailDirective, "aparte-scroll-rail", never, { "target": { "alias": "target"; "required": false; }; "every": { "alias": "every"; "required": false; }; "dataEmpty": { "alias": "dataEmpty"; "required": false; }; }, { "scrollRailJump": "scrollRailJump"; }, never, never, true, never>;
    static ngAcceptInputType_dataEmpty: 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 the dropdown. */
    set disabled(v: boolean);
    /** Adds a filter field above the options. Read on the first render only. */
    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; }; "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_searchable: unknown;
    static ngAcceptInputType_open: unknown;
}
/** `<aparte-sidebar>` — The column beside the chat — conversations, a new-chat button, a search field, an account row — as an element, because it has behaviour: it collapses, it becomes a drawer on a narrow window, and its search field filters the conversation list. */
export declare class AparteSidebarDirective extends AparteElementBase {
    /** Hidden (in the flow) or closed (as a drawer). Reflected; set it to start closed. */
    set collapsed(v: boolean);
    /** The window width under which the sidebar becomes a drawer: a length (default `48rem`), or `none` for a column that never does. */
    set breakpoint(v: string | undefined);
    /** Reflected BY the element while the window is narrower than `breakpoint` (48rem unless you set it). Read-only. */
    set dataDrawer(v: boolean);
    /** The sidebar opened or closed, by a toggle, by Escape, by a click on the scrim or by `collapsed` being set. Bubbles. */
    readonly sidebarToggle: EventEmitter<AparteSidebarToggleDetail>;
    protected onSidebarToggle(e: CustomEvent<AparteSidebarToggleDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteSidebarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteSidebarDirective, "aparte-sidebar", never, { "collapsed": { "alias": "collapsed"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "dataDrawer": { "alias": "dataDrawer"; "required": false; }; }, { "sidebarToggle": "sidebarToggle"; }, never, never, true, never>;
    static ngAcceptInputType_collapsed: unknown;
    static ngAcceptInputType_dataDrawer: unknown;
}
/** `<aparte-split>` — Two panes and a draggable seam — a chat beside a preview, an editor, an artifact card. */
export declare class AparteSplitDirective extends AparteElementBase {
    /** The primary pane's size, as a percentage of the container. Reflected on commit, never per drag frame. */
    set position(v: number);
    /** `horizontal` (panes side by side, the default) or `vertical` (stacked). Names the CONTAINER's axis. */
    set orientation(v: string | undefined);
    /** `start` (default) or `end`: which pane `position` sizes. */
    set primary(v: string | undefined);
    /** The primary pane folded to its minimum. Enter on the seam toggles it; a second Enter restores the size it had. */
    set collapsed(v: boolean);
    /** Below this width the split shows one pane at a time. A length (default `48rem`), or `none` to never stack. */
    set breakpoint(v: string | undefined);
    /** `start` (default) or `end`: which pane is shown while stacked. */
    set pane(v: string | undefined);
    /** No drag, no keys, no tab stop; the seam stays drawn. */
    set disabled(v: boolean);
    /** The seam's accessible name. Defaults to the locale's `splitHandleLabel`. */
    set label(v: string | undefined);
    /** Show one pane — the one `pane` names — whatever the width: the seam and the other pane are gone, as under the breakpoint. For a host that decides itself when a second pane exists (a preview with nothing to preview yet). `collapsed` is not this: it folds the primary pane to `--aparte-split-min` and keeps the seam. The CSS route, `.aparte-split--only-start` / `--only-end`, is the same state for a host that owns its breakpoints. */
    set single(v: boolean);
    /** Written BY the element while one pane is shown. Read-only; style against it. */
    set dataStacked(v: boolean);
    /** The position settled: after a drag, a key, a double-click or a property set. Never during a drag — persist from here. */
    readonly splitResize: EventEmitter<AparteSplitResizeDetail>;
    protected onSplitResize(e: CustomEvent<AparteSplitResizeDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteSplitDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteSplitDirective, "aparte-split", never, { "position": { "alias": "position"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "primary": { "alias": "primary"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "pane": { "alias": "pane"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "single": { "alias": "single"; "required": false; }; "dataStacked": { "alias": "dataStacked"; "required": false; }; }, { "splitResize": "splitResize"; }, never, never, true, never>;
    static ngAcceptInputType_position: unknown;
    static ngAcceptInputType_collapsed: unknown;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_single: unknown;
    static ngAcceptInputType_dataStacked: unknown;
}
/** `<aparte-suggestions>` — Prompt starters — a row of suggested prompts a reader clicks instead of typing. */
export declare class AparteSuggestionsDirective extends AparteElementBase {
    /** The starters, as a JSON array: strings, or `{ "label", "prompt" }` objects when the visible label and the sent text differ. The `suggestions` PROPERTY takes the same shape without the JSON. */
    set suggestions(v: string | undefined);
    /** The id of the `<aparte-chat>` whose composer should receive the click, when the element is not inside that composer. */
    set target(v: string | undefined);
    /** `send` (default): the click fills the composer and submits. `fill`: the click fills the composer and focuses it, so the reader edits first. */
    set mode(v: string | undefined);
    /** Hides the row (`hidden`) once its composer has sent something. Remove the attribute, or `hidden`, to show it again. */
    set emptyOnly(v: boolean);
    /** Reflected BY the element while it has no suggestion to show; the stylesheet hides it then. Read-only, do not set it yourself. */
    set dataEmpty(v: boolean);
    /** A starter was clicked. Bubbles, and is cancelable: `preventDefault()` stops the composer from being filled or submitted. Angular: this Output emits the detail, so preventDefault() is not on it — bind the DOM event for that: (aparte-suggestion)="$event.preventDefault()". */
    readonly suggestion: EventEmitter<AparteSuggestionEventDetail>;
    protected onSuggestion(e: CustomEvent<AparteSuggestionEventDetail>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AparteSuggestionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AparteSuggestionsDirective, "aparte-suggestions", never, { "suggestions": { "alias": "suggestions"; "required": false; }; "target": { "alias": "target"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "emptyOnly": { "alias": "emptyOnly"; "required": false; }; "dataEmpty": { "alias": "dataEmpty"; "required": false; }; }, { "suggestion": "suggestion"; }, never, never, true, never>;
    static ngAcceptInputType_emptyOnly: unknown;
    static ngAcceptInputType_dataEmpty: 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 AparteContextDirective, typeof AparteConversationListDirective, typeof AparteElicitationDirective, typeof AparteIconDirective, typeof AparteOptgroupDirective, typeof AparteOptionDirective, typeof AparteProgressSpinnerDirective, typeof AparteScrollRailDirective, typeof AparteSelectDirective, typeof AparteSidebarDirective, typeof AparteSplitDirective, typeof AparteSuggestionsDirective];
export {};