import { j as WalkedField, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
import { t as Diagnostic } from "../diagnostics-mftUZI7c.mjs";
import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
import { r as LitRenderProps, t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
import { LitElement, TemplateResult } from "lit";

//#region src/lit/SchemaComponent.d.ts
/**
 * Public change-event detail emitted on the top-level `<schema-component>`.
 *
 * The `value` payload carries the updated root value as returned by
 * the user's most recent edit. Consumers wire this into their
 * framework's binding system — React via `addEventListener` on the
 * canonical `change` event, Vue via a `@change` directive, Svelte
 * via `on:change`. The detail object always carries a single
 * `value` field with the post-edit root value.
 */
interface SchemaChangeEventDetail {
  value: unknown;
}
/**
 * Lit Custom Element for editable schema-driven UI.
 *
 * Tag: `<schema-component>` (default) or `<{prefix}schema-component>`
 * (when `registerSchemaComponents(prefix)` is called).
 *
 * **Required:** call {@link registerSchemaComponents} once at module
 * setup before instantiating this element in HTML markup, otherwise
 * none of the per-type `<sc-*>` children will upgrade and the tree
 * will render as unknown elements.
 */
declare class SchemaComponent extends LitElement {
  /**
   * Element property declarations.
   *
   * All four "data" properties (`schema`, `value`, `resolver`,
   * `widgets`) carry `attribute: false`: Custom Element attributes
   * are strings, and these payloads (an arbitrary Zod schema, an
   * arbitrary JS value, a resolver function map, a widget tag map)
   * cannot round-trip through attribute serialisation. Set them via
   * direct property assignment.
   *
   * `readOnly` is a boolean attribute (and reflects to DOM) so the
   * common "render read-only view" case is reachable from plain
   * HTML markup (`<schema-component readonly></schema-component>`).
   * The capitalisation is `readOnly` on the property and `readonly`
   * on the attribute — matching the HTML `readonly` attribute on
   * `<input>` / `<textarea>`.
   */
  static readonly properties: {
    schema: {
      attribute: boolean;
    };
    value: {
      attribute: boolean;
    };
    resolver: {
      attribute: boolean;
    };
    widgets: {
      attribute: boolean;
    };
    fields: {
      attribute: boolean;
    };
    meta: {
      attribute: boolean;
    };
    schemaRef: {
      attribute: boolean;
    };
    io: {
      attribute: boolean;
    };
    idPrefix: {
      attribute: boolean;
    };
    onDiagnostic: {
      attribute: boolean;
    };
    readOnly: {
      type: BooleanConstructor;
      reflect: boolean;
      attribute: string;
    };
    strict: {
      type: BooleanConstructor;
    };
  };
  /**
   * Reactive property declarations. Each field is declared with
   * `declare` (no runtime emit) so Lit's `static properties`
   * accessors are not shadowed by class-field initialisers. Default
   * values are seeded in the constructor.
   */
  schema: unknown;
  schemaRef: string | undefined;
  io: SchemaIoSide | undefined;
  value: unknown;
  resolver: LitComponentResolver | undefined;
  widgets: ReadonlyMap<string, string> | undefined;
  fields: Record<string, unknown> | undefined;
  meta: SchemaMeta | undefined;
  idPrefix: string | undefined;
  readOnly: boolean;
  strict: boolean;
  onDiagnostic: ((diagnostic: Diagnostic) => void) | undefined;
  constructor();
  render(): TemplateResult;
  /**
   * Build the recursive `renderChild` closure threaded through every
   * container renderer.
   */
  protected makeRenderChild(currentDepth: number, parentPath: string, userResolver: LitComponentResolver): LitRenderProps["renderChild"];
  /**
   * Dispatch a single walked field through the resolver, widget
   * registry, and recursion limit. Parallel to
   * `renderField` in `react/SchemaComponent.tsx`.
   */
  protected renderField(tree: WalkedField, value: unknown, change: (next: unknown) => void, userResolver: LitComponentResolver, renderChild: LitRenderProps["renderChild"], path: string): TemplateResult;
  private applyWidgetProperties;
  private buildDiagnostics;
}
//#endregion
export { SchemaChangeEventDetail, SchemaComponent };