import { Context } from "@lit/context";
import { DataTag, DefaultLayerError, ErrorOf, InferValidatorOutput, LayerCallContext, LayerClient, LayerComponentProps, LayerGroupOptions, LayerHandle, LayerKey, LayerOptions, LayerState, OmitKeyof, OpenLayerOptions, ResponseOf, ValidatedLayerHandle, Validator } from "@stainless-code/layers";
import { LitElement, PropertyValues, ReactiveController, ReactiveControllerHost, TemplateResult, nothing } from "lit";
export * from "@stainless-code/layers";
//#region src/index.d.ts
/**
 * `@lit/context` key for the nearest {@link LayerClient}.
 * Exported for advanced `ContextProvider` wiring; prefer
 * {@link provideLayerClient} / {@link useLayerClient}.
 */
declare const layerClientContext: Context<string, LayerClient>;
/** Lit host that can own reactive controllers and participate in `@lit/context`. */
type LitControllerHost = ReactiveControllerHost & HTMLElement;
/**
 * Provides a {@link LayerClient} to descendant consumers via `@lit/context`.
 *
 * Attaches a `@lit/context` `ContextProvider` to `host`; descendants resolve it
 * with {@link useLayerClient} or by omitting `client` on a hook. A new client is
 * created when `client` is omitted.
 *
 * @param host Lit element host that owns the context provider.
 * @param client Optional client to provide; a new {@link LayerClient} is created when omitted.
 * @returns The provided client.
 */
declare function provideLayerClient(host: LitControllerHost, client?: LayerClient): LayerClient;
/**
 * Reactive controller that resolves the nearest {@link LayerClient} from
 * `@lit/context` and exposes it via {@link LayerClientConsumer.current}.
 *
 * The value is undefined until the host connects under a provider; `.current`
 * throws when accessed before a client is available.
 */
declare class LayerClientConsumer implements ReactiveController {
  #private;
  constructor(host: LitControllerHost);
  hostConnected(): void;
  hostDisconnected(): void;
  /** The resolved client; throws when no provider has supplied one yet. */
  get current(): LayerClient;
}
/**
 * Resolve the nearest {@link LayerClient} from `@lit/context`.
 *
 * Returns a {@link LayerClientConsumer} controller; read the client via
 * `.current` (throws when no provider has supplied one yet). Prefer passing
 * `client` explicitly on `useStack` / `useLayer` for synchronous access at
 * construction time — context only resolves once the host is connected.
 *
 * @returns A {@link LayerClientConsumer} controller; read `.current` for the client.
 */
declare function useLayerClient(host: LitControllerHost): LayerClientConsumer;
type NoValidateOptions<Opts> = Opts extends {
  validate: Validator<unknown>;
} ? never : Opts;
interface UseStackOptions<T = LayerState[]> {
  stack?: string;
  select?: (states: LayerState[]) => T;
  compare?: (a: T, b: T) => boolean;
  client?: LayerClient;
}
interface UseLayerStateOptions<Key extends LayerKey, P = unknown, D = unknown, U = LayerState<P, ResponseOf<Key>, ErrorOf<Key>, D>[]> {
  key: Key;
  stack?: string;
  select?: (states: LayerState<P, ResponseOf<Key>, ErrorOf<Key>, D>[]) => U;
  compare?: (a: U, b: U) => boolean;
}
/**
 * Reactive controller that mirrors a {@link LayerClient} stack snapshot.
 * Prefer {@link useStack} / {@link useQueuedStack}; `queued` / `deferClient` /
 * {@link bindClient} are for adapter internals (shared lazy context resolve).
 */
declare class StackController<T = LayerState[]> implements ReactiveController {
  #private;
  /**
   * @param queued When `true`, observe {@link LayerStack.getQueuedSnapshot}
   *   instead of the mounted snapshot (`useQueuedStack`).
   * @param deferClient When `true`, skip lazy context resolve so a sibling
   *   controller can call {@link bindClient} after one shared resolve.
   */
  constructor(host: ReactiveControllerHost, options?: UseStackOptions<T>, client?: LayerClient, queued?: boolean, deferClient?: boolean);
  /**
   * Bind a {@link LayerClient} when constructed with `deferClient` (internal:
   * {@link LayerController} / {@link LayerGroupController} share one lazy
   * context resolve across their stack controllers).
   */
  bindClient(client: LayerClient): void;
  /**
   * Tear down the current subscription, apply new options, and re-subscribe when
   * the host is connected.
   */
  reconfigure(options?: UseStackOptions<T>, client?: LayerClient): void;
  hostConnected(): void;
  hostDisconnected(): void;
  /** Selected stack value; updates when the stack publishes a new snapshot. */
  get current(): T;
}
/**
 * Subscribe a Lit host to a {@link LayerClient} stack via {@link StackController}.
 *
 * @param host Reactive controller host (typically `this` on a `LitElement`).
 * @param opts `stack`, `select`, `compare`, and optional `client`.
 * @param client Client to observe when not passed on `opts`.
 * @returns A {@link StackController} whose `.current` mirrors the selected snapshot.
 * @default opts.stack `"default"`
 * @default opts.select all mounted states (identity)
 * @default opts.compare `Object.is`
 */
declare function useStack<T = LayerState[]>(host: ReactiveControllerHost, opts?: UseStackOptions<T>, client?: LayerClient): StackController<T>;
/**
 * Subscribe a Lit host to a stack's queued snapshot via {@link StackController}.
 *
 * @param host Reactive controller host (typically `this` on a `LitElement`).
 * @param opts `stack`, `select`, `compare`, and optional `client`.
 * @param client Client to observe when not passed on `opts`.
 * @returns A {@link StackController} whose `.current` mirrors the queued snapshot.
 */
declare function useQueuedStack<T = LayerState[]>(host: ReactiveControllerHost, opts?: UseStackOptions<T>, client?: LayerClient): StackController<T>;
/**
 * Observe all mounted layers matching a key.
 *
 * A {@link DataTag} key infers its response and error types.
 */
declare function useLayerState<Key extends LayerKey, P = unknown, D = unknown, U = LayerState<P, ResponseOf<Key>, ErrorOf<Key>, D>[]>(host: ReactiveControllerHost, opts: UseLayerStateOptions<Key, P, D, U>, client?: LayerClient): StackController<U>;
/** Observe all queued layers matching a key. */
declare function useLayerQueuedState<Key extends LayerKey, P = unknown, D = unknown, U = LayerState<P, ResponseOf<Key>, ErrorOf<Key>, D>[]>(host: ReactiveControllerHost, opts: UseLayerStateOptions<Key, P, D, U>, client?: LayerClient): StackController<U>;
type WiredLayerHandle<P, R, E = DefaultLayerError, D = unknown, RP = unknown> = LayerHandle<P, R, E, D, RP> & {
  state: StackController<LayerState<P, R, E, D>[]>;
  queued: StackController<LayerState<P, R, E, D>[]>;
  top: LayerState<P, R, E, D> | null;
};
type WiredValidatedLayerHandle<V extends Validator<unknown>, R, E = DefaultLayerError, D = unknown, RP = unknown> = ValidatedLayerHandle<V, R, E, D, RP> & {
  state: StackController<LayerState<InferValidatorOutput<V>, R, E, D>[]>;
  queued: StackController<LayerState<InferValidatorOutput<V>, R, E, D>[]>;
  top: LayerState<InferValidatorOutput<V>, R, E, D> | null;
};
/**
 * Reactive controller wiring `createLayer` with reactive `state` / `queued` /
 * `top` for a single layer key.
 */
declare class LayerController<P, R, E = DefaultLayerError, D = unknown, RP = unknown> implements ReactiveController {
  #private;
  constructor(host: ReactiveControllerHost, options: LayerOptions<P, R, E, D, RP> & {
    key: LayerKey;
  }, client?: LayerClient);
  hostConnected(): void;
  hostDisconnected(): void;
  get open(): LayerHandle<P, R, E, D, RP>["open"];
  get upsert(): LayerHandle<P, R, E, D, RP>["upsert"];
  get dismiss(): LayerHandle<P, R, E, D, RP>["dismiss"];
  get update(): LayerHandle<P, R, E, D, RP>["update"];
  get cancelQueued(): LayerHandle<P, R, E, D, RP>["cancelQueued"];
  get client(): LayerHandle<P, R, E, D, RP>["client"];
  get stack(): LayerHandle<P, R, E, D, RP>["stack"];
  get options(): LayerHandle<P, R, E, D, RP>["options"];
  get current(): LayerHandle<P, R, E, D, RP>["current"];
  get state(): StackController<LayerState<P, R, E, D>[]>;
  get queued(): StackController<LayerState<P, R, E, D>[]>;
  get top(): LayerState<P, R, E, D> | null;
}
/** Wired handle: `createLayer` + reactive `state`/`queued`/`top`. */
declare function useLayer<V extends Validator<unknown>, R, E = DefaultLayerError, D = unknown, RP = unknown>(host: ReactiveControllerHost, options: LayerOptions<InferValidatorOutput<V>, R, E, D, RP> & {
  key: LayerKey;
  validate: V;
}, client?: LayerClient): WiredValidatedLayerHandle<V, R, E, D, RP>;
declare function useLayer<P, R, E = DefaultLayerError, D = unknown, RP = unknown>(host: ReactiveControllerHost, options: NoValidateOptions<LayerOptions<P, R, E, D, RP> & {
  key: LayerKey;
}>, client?: LayerClient): WiredLayerHandle<P, R, E, D, RP>;
interface StackHandles {
  states: StackController<LayerState[]>;
  getCall: (state: LayerState) => LayerCallContext<unknown, unknown>;
}
/**
 * Reactive controller exposing the states and call contexts needed to render
 * a stack headlessly (without `StackOutlet`).
 */
declare class StackHandlesController implements ReactiveController {
  #private;
  constructor(host: ReactiveControllerHost, stack?: string, rootProps?: unknown, client?: LayerClient);
  hostConnected(): void;
  hostDisconnected(): void;
  get states(): StackController<LayerState<unknown, void, Error, unknown>[]>;
  getCall: (state: LayerState) => LayerCallContext<unknown, unknown>;
}
/** Return the states and call contexts needed to render a stack headlessly. */
declare function useStackHandles(host: ReactiveControllerHost, stack?: string, rootProps?: unknown, client?: LayerClient): StackHandlesController;
interface MutationRun<R> {
  /** On success, end the layer with `response`; on failure, leave it open and rethrow. */
  orEnd: (response: R) => Promise<void>;
}
interface MutationFlow<R> {
  /** True while a `run(...)` async action is in flight. Mirrors the layer's `actionStatus: "running"`. */
  pending: boolean;
  run: (fn: () => Promise<void> | void) => MutationRun<R>;
}
/**
 * Reactive controller coordinating a layer's pending state with an async
 * mutation and ending it on success.
 */
declare class MutationFlowController<R> implements ReactiveController {
  #private;
  constructor(host: ReactiveControllerHost, call: LayerCallContext<unknown, R>);
  hostConnected(): void;
  hostDisconnected(): void;
  get pending(): boolean;
  run: (fn: () => Promise<void> | void) => MutationRun<R>;
}
/**
 * Coordinate a layer's pending state with an async mutation and end it on success.
 *
 * @example
 * ```ts
 * @customElement("confirm-dialog")
 * class ConfirmDialog extends LitElement {
 *   @property({ attribute: false }) call!: LayerCallContext<void, boolean>;
 *   #flow = new MutationFlowController(this, this.call);
 *   render() {
 *     return html`<button @click=${() => this.#flow.run(async () => {}).orEnd(true)}>Yes</button>`;
 *   }
 * }
 * ```
 */
declare function useMutationFlow<P, R, RootProps = unknown>(host: ReactiveControllerHost, call: LayerCallContext<P, R, RootProps>): MutationFlowController<R>;
/** Open a layer on a pre-bound stack, with {@link DataTag} response and error inference. */
interface ScopedOpen {
  <P, R, E = DefaultLayerError, D = unknown, RootProps = unknown>(options: OmitKeyof<OpenLayerOptions<P, R, E, D, RootProps> & {
    key: DataTag<LayerKey, R, E>;
  }, "stack" | "validate">): Promise<R>;
  <P, R = void, E = DefaultLayerError, D = unknown, RootProps = unknown>(options: OmitKeyof<OpenLayerOptions<P, R, E, D, RootProps>, "stack">): Promise<R>;
}
interface LayerGroup {
  open: ScopedOpen;
  dismissAll: (response?: unknown) => void;
  states: StackController<LayerState[]>;
  /** Renders the child stack inline — place inside the parent layer's DOM. */
  outlet: (rootProps?: unknown) => TemplateResult;
  stackId: string;
}
/**
 * Reactive controller for a child stack scoped to the calling layer's lifetime.
 *
 * The child stack is disposed and cleared via `cancelAll` when its parent
 * layer unmounts (`LayerCancelledError`).
 * {@link LayerGroupController.outlet} returns a `TemplateResult` that renders the
 * child stack inline (router `Routes.outlet()`-shaped) — share the render helper
 * with `StackOutlet`.
 */
declare class LayerGroupController<P, R, RootProps = unknown> implements ReactiveController {
  #private;
  constructor(host: ReactiveControllerHost, call: LayerCallContext<P, R, RootProps>, options?: LayerGroupOptions, client?: LayerClient);
  hostConnected(): void;
  hostDisconnected(): void;
  get stackId(): string;
  get states(): StackController<LayerState[]>;
  open: ScopedOpen;
  dismissAll: (response?: unknown) => void;
  outlet: (rootProps?: unknown) => TemplateResult;
}
/**
 * Create a child stack scoped to the calling layer's lifetime.
 *
 * The child stack is disposed and cleared via `cancelAll` when its parent
 * layer unmounts (`LayerCancelledError`).
 */
declare function useLayerGroup<P, R, RootProps = unknown>(host: ReactiveControllerHost, call: LayerCallContext<P, R, RootProps>, options?: LayerGroupOptions, client?: LayerClient): LayerGroup;
/** A layer component is either a `LitElement` constructor or a render function. */
type LitLayerComponent = (new () => LitElement) | ((props: LayerComponentProps) => TemplateResult);
/**
 * `<stack-provider>` — provides a {@link LayerClient} via `@lit/context`.
 * Shadow root + `<slot>`; composed `context-request` still reaches light children.
 *
 * Register with {@link defineStackElements}. Omitting `.client` creates one.
 */
declare class StackProvider extends LitElement {
  #private;
  static properties: {
    client: {
      attribute: boolean;
    };
  };
  client: LayerClient | undefined;
  constructor();
  connectedCallback(): void;
  updated(changed: PropertyValues<this>): void;
  render(): TemplateResult;
}
/**
 * `<stack-outlet>` — renders every active layer in a stack with its registered
 * component. Light DOM (`createRenderRoot()` returns `this`) so overlays stack
 * inline where mounted. Id-keyed `repeat` keeps instances stable across updates.
 */
declare class StackOutlet extends LitElement {
  #private;
  static properties: {
    stack: {
      type: StringConstructor;
    };
    rootProps: {
      attribute: boolean;
    };
    client: {
      attribute: boolean;
    };
  };
  stack: string;
  rootProps: unknown;
  client: LayerClient | undefined;
  constructor();
  createRenderRoot(): this;
  updated(changed: PropertyValues<this>): void;
  connectedCallback(): void;
  render(): TemplateResult | typeof nothing;
}
/**
 * `<stack-subscribe>` — renders a selected stack value through a `.renderer`
 * callback (virtualizer `.renderItem`-shaped). Set `.stack`, `.selector`, and
 * `.renderer` (a `(value) => TemplateResult`).
 */
declare class StackSubscribe extends LitElement {
  #private;
  static properties: {
    stack: {
      type: StringConstructor;
    };
    selector: {
      attribute: boolean;
    };
    renderer: {
      attribute: boolean;
    };
  };
  stack: string;
  selector: (states: LayerState[]) => unknown;
  renderer: (value: unknown) => TemplateResult;
  constructor();
  createRenderRoot(): this;
  connectedCallback(): void;
  updated(changed: PropertyValues<this>): void;
  render(): TemplateResult;
}
interface AppStack {
  open: ScopedOpen;
  dismissAll: (response?: unknown) => void;
  states: StackController<LayerState[]>;
}
/**
 * Reactive controller exposing `open` / `dismissAll` / `states` bound to one
 * stack. Returned by {@link createStackHook} as `useAppStack`.
 */
declare class AppStackController implements ReactiveController {
  #private;
  constructor(host: ReactiveControllerHost, client: LayerClient | undefined, stackId: string);
  hostConnected(): void;
  hostDisconnected(): void;
  get states(): StackController<LayerState[]>;
  open: ScopedOpen;
  dismissAll: (response?: unknown) => void;
}
/**
 * `<app-host>` — light-DOM host that renders a `stack-outlet` for its `.stack`.
 * Forward host props to layers via `.rootProps` (defaults to the host element).
 * Register with {@link defineStackElements}; {@link createStackHook} returns a
 * subclass bound to its stack id.
 */
declare class AppHostElement extends LitElement {
  static properties: {
    stack: {
      type: StringConstructor;
    };
    rootProps: {
      attribute: boolean;
    };
  };
  stack: string;
  rootProps: unknown;
  constructor();
  createRenderRoot(): this;
  render(): TemplateResult;
}
interface AppLayerProps<P, R = unknown> {
  /** Layer definition with the stack supplied by the factory. */
  options: OmitKeyof<LayerOptions<P, R>, "stack">;
  /** Controlled visibility. `true` opens the layer; `false` dismisses it. */
  open: boolean;
  payload: P;
  /** Called when the layer resolves. */
  onResolved?: (response: R) => void;
}
/**
 * Reactive controller for a controlled layer bound to one stack. Set `.open` to
 * `true` to open and `false` to dismiss; `.payload` / `.options` / `.onResolved`
 * update the live layer. Dismisses automatically when the host disconnects.
 */
declare class AppLayerController<P = unknown, R = unknown> implements ReactiveController {
  #private;
  options: OmitKeyof<LayerOptions<P, R>, "stack">;
  payload: P;
  onResolved?: (response: R) => void;
  constructor(host: ReactiveControllerHost, client: LayerClient | undefined, stackId: string, props: AppLayerProps<P, R>);
  get open(): boolean;
  set open(v: boolean);
  hostConnected(): void;
  hostDisconnected(): void;
}
interface StackHook {
  /** Provider CE subclass bound to the hook's default client. */
  StackProvider: typeof StackProvider;
  /** Reactive controller for the bound stack's `open` / `dismissAll` / `states`. */
  useAppStack: (host: ReactiveControllerHost) => AppStackController;
  /** `<app-host>` subclass bound to the hook's stack id. */
  AppHost: typeof AppHostElement;
  /** Controlled-layer controller constructor bound to the hook's stack. */
  AppLayer: new (host: ReactiveControllerHost, props: AppLayerProps<unknown, unknown>) => AppLayerController;
}
/**
 * Create a provider, app-stack controller, app-host, and controlled-layer
 * controller bound to one stack. Mirrors the React/Vue/Solid `createStackHook`.
 */
declare function createStackHook(config?: {
  client?: LayerClient;
  stack?: string;
}): StackHook;
/**
 * Idempotently register the stack custom elements: `stack-provider`,
 * `stack-outlet`, `stack-subscribe`, and `app-host`. Safe to call multiple
 * times; not auto-invoked on import (tenets 2 + 4).
 */
declare function defineStackElements(): void;
//#endregion
export { AppHostElement, AppLayerController, AppLayerProps, AppStack, AppStackController, LayerClientConsumer, LayerController, LayerGroup, LayerGroupController, LitControllerHost, LitLayerComponent, MutationFlow, MutationFlowController, MutationRun, ScopedOpen, StackController, StackHandles, StackHandlesController, StackHook, StackOutlet, StackProvider, StackSubscribe, UseLayerStateOptions, UseStackOptions, WiredLayerHandle, WiredValidatedLayerHandle, createStackHook, defineStackElements, layerClientContext, provideLayerClient, useLayer, useLayerClient, useLayerGroup, useLayerQueuedState, useLayerState, useMutationFlow, useQueuedStack, useStack, useStackHandles };