import { type AutocompleteResult, type CompletedParamState, type CustomFieldsReport, type IdentifiedParamState, type Product, type Segment, type SkippedParamState, type Suggestion, type SuggestionOption } from "@magicx-eng/ai-autocomplete-vanilla";
import { type Observable } from "rxjs";
import type { AIAutocompleteControllerOptions, AIAutocompleteControllerState, AIAutocompleteControllerUpdate, AIAutocompleteDropdownState } from "../shared/types";
/**
 * Tier 2 logic surface for `@magicx-eng/ai-autocomplete-angular` — the Angular
 * equivalent of React's `useAIAutocomplete()` hook. Wraps a headless
 * `@magicx-eng/ai-autocomplete-vanilla` core and exposes its state as RxJS
 * observables plus thin action methods.
 *
 * The controller is consumer-managed — the consumer creates it
 * with `new`, holds the reference, and **must call `destroy()`** in their
 * own `ngOnDestroy`. The Tier 1 `<ai-autocomplete>` component does this
 * automatically; Tier 2 consumers do not get auto-cleanup.
 *
 * @public
 */
export declare class AIAutocompleteController {
    private readonly core;
    private readonly rawState$;
    private readonly optionsPosition$;
    private readonly unsubscribeCore;
    private isDestroyed;
    /** Plain-text content of the editor. */
    readonly text$: Observable<string>;
    /** Completed (bold) params currently in the editor. */
    readonly completedParams$: Observable<CompletedParamState[]>;
    /**
     * Suggestions the user dismissed with the skip key (→). Nothing renders
     * them; they exist so a hand-rolled submit can pass them to
     * `buildSubmitResult` and carry the same `text: "skipped"` entries the
     * SDK's own requests do.
     */
    readonly skippedParams$: Observable<SkippedParamState[]>;
    /**
     * Params the server identified in the user's own words. Already rendered
     * through `segments$`; exposed so a hand-rolled submit can pass them to
     * `buildSubmitResult` and report the same `identified_params` the SDK's
     * own results carry.
     */
    readonly identifiedParams$: Observable<IdentifiedParamState[]>;
    /** Actionable suggestion pills (first one is the active pill). */
    readonly suggestionPills$: Observable<Suggestion[]>;
    /** Text + completed-param segments for rendering the editor body. */
    readonly segments$: Observable<Segment[]>;
    /** ID of the most-recently-promoted param (drives shimmer animation). */
    readonly newParamId$: Observable<string | null>;
    /** All suggestions from the server (including non-actionable ones). */
    readonly suggestions$: Observable<Suggestion[]>;
    /**
     * What the product strip shows: the items the latest `/suggest` response
     * reported as matching the query, or — with `products` configured on the
     * controller — the results of that custom search.
     */
    readonly products$: Observable<Product[]>;
    /**
     * The catalog grounding report the latest response carried, or null when it
     * carried none: which of the query's constraints the catalog applied, which
     * it dropped, and how many items (and which) the applied ones left
     * standing. Null is "no news", not an empty catalog.
     */
    readonly customFields$: Observable<CustomFieldsReport | null>;
    /** Currently highlighted dropdown option index. -1 = none. */
    readonly activeIndex$: Observable<number>;
    /**
     * UI-visible loading flag — suppressed during the post-select press
     * animation and during re-edit (cached options stay visible there). Use
     * this instead of the raw core state for any loading-skeleton binding.
     */
    readonly isLoading$: Observable<boolean>;
    /** Server-reported "query is complete" flag. */
    readonly isReady$: Observable<boolean>;
    /** Whether the editor currently has focus. */
    readonly isFocused$: Observable<boolean>;
    /** Whether the dropdown should currently be visible. */
    readonly isDropdownOpen$: Observable<boolean>;
    /**
     * Whether the active (leading) pill should render selected (full opacity)
     * rather than the de-emphasized `first` tier. Auto trigger ⇒ true only while
     * a dropdown option is highlighted; manual ⇒ true once the pill is tapped.
     */
    readonly isActivePillSelected$: Observable<boolean>;
    /** Server-suggested placeholder text for the editor. */
    readonly placeholderText$: Observable<string>;
    /** Last fetch error, or null. */
    readonly error$: Observable<Error | null>;
    /** Param currently being re-edited, or null. */
    readonly editingParam$: Observable<CompletedParamState | null>;
    /** Plain-text offset where the edit region starts, or null. */
    readonly editingAnchor$: Observable<number | null>;
    /** Live caret offset within the editor. */
    readonly caretOffset$: Observable<number | null>;
    /**
     * Snapshot of every public field in one object. Convenient for
     * `*ngIf="ctrl.state$ | async as state"` templating — aliases all fields
     * under a single subscription instead of multiple `| async` pipes.
     */
    readonly state$: Observable<AIAutocompleteControllerState>;
    /**
     * Composite state for the dropdown view. Tier 2 consumers spread this into
     * `<ai-autocomplete-dropdown>`; Tier 1 uses the same shape internally.
     */
    readonly dropdown$: Observable<AIAutocompleteDropdownState>;
    /**
     * Throws if invoked outside a browser environment. For SSR / Angular
     * Universal, gate construction with `isPlatformBrowser`.
     */
    constructor(opts?: AIAutocompleteControllerOptions);
    /** Stable ARIA listbox ID for the dropdown. Pass to `<textarea aria-controls="...">`. */
    get listboxId(): string;
    /** Whether `destroy()` has been called. After destruction all action methods no-op. */
    get destroyed(): boolean;
    /**
     * Synchronous snapshot of the controller's current public state. Mirrors
     * the latest emission of `state$`. Useful in callbacks where you can't
     * `subscribe` (e.g. inside an event handler).
     */
    getState(): AIAutocompleteControllerState;
    /**
     * The structured query as the SDK understands it right now — the same
     * object `onResult` delivers after each response and `onSubmit` delivers
     * on submit. Read it on demand from a place that has no event handy (a
     * custom submit button, a "save draft" action).
     */
    getResult(): AutocompleteResult;
    /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */
    reset(): void;
    /**
     * Records a submit in telemetry. Enter is recorded by the SDK; call this
     * from a submit button you render, so each submit is counted once.
     */
    recordSubmit(result: AutocompleteResult): void;
    /** Pick a dropdown option (or replace the re-edited param if in re-edit mode). */
    selectOption(option: SuggestionOption): void;
    /**
     * Announce a product selection — fires the `onProductSelect` callback the
     * controller was constructed with. `<ai-autocomplete-dropdown>` calls this
     * for you; consumers rendering their own strip call it themselves.
     *
     * Emitting is the whole behaviour: the SDK deliberately does not navigate to
     * `product.url`, because only the integration knows whether a selection
     * means "open the PDP", "add to cart", or "fill the input".
     */
    selectProduct(product: Product): void;
    /** Promote the pill at `index` to active (front of the list). */
    setActivePill(index: number): void;
    /**
     * Skip the active pill — same action as pressing → at the end of the input.
     * The dropdown's skip button calls this; consumers rendering their own skip
     * affordance call it directly. The skipped suggestion joins `skippedParams$`.
     */
    skipActivePill(): void;
    /** Drop the last completed param's "completed" status. Text stays as plain text. */
    removeLastParam(): void;
    /** Clear the shimmer animation state for the most-recently-added param. */
    clearNewParamId(): void;
    /** Controlled-mode setter for editor text. */
    setValue(text: string): void;
    /** Controlled-mode setter for completed params. */
    setCompletedParams(params: CompletedParamState[]): void;
    /** Forward plain-text input from the consumer's `<textarea>` to the core. */
    handleTextChange(value: string): void;
    /** Forward keyboard events from the consumer's `<textarea>` to the core. */
    handleKeyDown(event: KeyboardEvent): void;
    /** Notify the core of focus state. */
    setFocused(focused: boolean): void;
    /** Enter re-edit mode for the bold param with the given id. */
    startEditingParam(paramId: string): void;
    /** Exit re-edit mode without changing the bold param. */
    exitEditMode(): void;
    /** Forward post-input caret position (extends the edit tail). */
    handleCaretAfterInput(offset: number | null): void;
    /** Forward selection-only caret moves (may exit re-edit). */
    handleCaretMove(offset: number | null): void;
    /** Replace the bold param being re-edited. Returns true when applied. */
    replaceEditingRange(replacement: string): boolean;
    /** Set the highlighted option index (typically driven by hover). */
    setActiveDropdownIndex(index: number): void;
    /**
     * The pointer left option `index`: clear the highlight if it is still on it,
     * so Enter afterwards submits instead of picking an option the pointer is no
     * longer on. A highlight the keyboard has since moved is left alone.
     */
    clearHighlight(index: number): void;
    /** Page the datepicker back one month. No-op unless a date pill is active. */
    showPreviousMonth(): void;
    /** Page the datepicker forward one month. No-op unless a date pill is active. */
    showNextMonth(): void;
    /**
     * Runs mapProducts synchronously on the shown items again without a request.
     * Keeps the same cards while updating their content.
     * Does nothing without mapProducts or with a custom products integration.
     */
    refreshProducts(): void;
    /**
     * Apply runtime changes to a subset of options. Event callbacks
     * (`onSubmit`, `onResult`, `onError`, etc.) cannot be swapped this way — they are
     * registered once at construction (matches the React hook's design). For
     * dynamic event reactivity, subscribe to the corresponding observable
     * (e.g. `text$` instead of `onChange`).
     */
    update(opts: AIAutocompleteControllerUpdate): void;
    /**
     * Release all resources — unsubscribes from the core, destroys the core,
     * and completes the internal state subject. Safe to call multiple times.
     * After destruction, action methods no-op silently.
     */
    destroy(): void;
}
//# sourceMappingURL=ai-autocomplete.controller.d.ts.map