import { TemplateResult } from '../processor/template-result';
/**
 * Result object for the `asyncReplace` directive.
 * Holds the current state of the tracked promise so the template
 * engine can render the appropriate branch on each update cycle.
 */
export declare class AsyncResult {
    readonly state: 'pending' | 'resolved' | 'rejected';
    readonly value?: unknown | undefined;
    readonly error?: unknown | undefined;
    constructor(state: 'pending' | 'resolved' | 'rejected', value?: unknown | undefined, error?: unknown | undefined);
}
/**
 * Tracks a Promise and triggers a component re-render when it settles.
 *
 * Usage inside a component's `template()`:
 * ```ts
 * // Create the tracker once (e.g. in onMount or a reactive getter)
 * this._userTracker = createAsyncTracker(fetchUser(id), () => this.requestUpdate());
 *
 * // In template():
 * ${resolveAsync(this._userTracker,
 *   (user) => html`<p>Hello ${user.name}</p>`,       // resolved
 *   () => html`<p>Loading...</p>`,                     // pending
 *   (err)  => html`<p>Error: ${err.message}</p>`       // rejected
 * )}
 * ```
 */
export interface AsyncTracker<T = unknown> {
    /** Current state of the tracked promise */
    readonly state: 'pending' | 'resolved' | 'rejected';
    /** Resolved value (only when state === 'resolved') */
    readonly value?: T;
    /** Rejection reason (only when state === 'rejected') */
    readonly error?: unknown;
}
/**
 * Create an AsyncTracker that calls `onSettle` when the promise resolves or rejects.
 * The component should call `this.requestUpdate()` inside `onSettle` to trigger a re-render.
 *
 * @param promise - The Promise to track
 * @param onSettle - Callback invoked when the promise settles (resolve or reject)
 */
export declare function createAsyncTracker<T>(promise: Promise<T>, onSettle: () => void): AsyncTracker<T>;
/**
 * Resolve an AsyncTracker into a template based on its current state.
 * Returns the appropriate branch template.
 *
 * @param tracker - The AsyncTracker to resolve
 * @param resolved - Template function for the resolved state
 * @param pending - Template function for the pending state (optional)
 * @param rejected - Template function for the rejected state (optional)
 *
 * @example
 * ```ts
 * template() {
 *   return html`
 *     ${resolveAsync(this.dataTracker,
 *       (data) => html`<div>${data.name}</div>`,
 *       () => html`<span>Loading...</span>`,
 *       (err) => html`<span class="error">${err}</span>`
 *     )}
 *   `;
 * }
 * ```
 */
export declare function resolveAsync<T, R extends TemplateResult>(tracker: AsyncTracker<T>, resolved: (value: T) => R, pending?: () => R, rejected?: (error: unknown) => R): R | undefined;
//# sourceMappingURL=await.d.ts.map