import { t as Constructor } from "../constructorTypes-BdCiMS6e.mjs";

//#region src/lit/registry.d.ts
/**
 * Mapping from the canonical built-in tag (without prefix) to the
 * `BaseScElement` subclass that backs it. Exported so consumers can
 * introspect what {@link registerSchemaComponents} will register —
 * useful for diagnostics and for building documentation surfaces.
 *
 * The top-level orchestrator elements (`schema-component`,
 * `schema-view`, `schema-field`) are listed alongside the per-type
 * `<sc-*>` elements; the structural type relaxes to `HTMLElement` so
 * every constructor is assignable.
 */
declare const BUILT_IN_ELEMENTS: Readonly<Record<string, Constructor<HTMLElement>>>;
/**
 * Register every built-in `<sc-*>` Custom Element on the global
 * `customElements` registry, optionally namespaced under `prefix`.
 *
 * Re-registering the same tag is a no-op — `customElements.get(tag)`
 * is checked first so calling this function twice (or alongside
 * another library that registered the same tag) does not throw.
 *
 * @param prefix - Optional prefix prepended to every built-in tag.
 *   E.g. `registerSchemaComponents("myapp-")` registers
 *   `<myapp-sc-string>`, `<myapp-sc-number>`, …, avoiding collisions
 *   with another library that may have shipped its own `<sc-*>`
 *   elements. Pass an empty string (the default) to use the
 *   canonical names.
 * @returns A {@link RegistrationResult} carrying the canonical-tag →
 *   registered-tag map and the list of elements skipped because the
 *   tag was already registered. The map is used by the default
 *   resolver to look up the right tag when the consumer chose a
 *   custom prefix.
 *
 * @example
 * ```ts
 * // Default registration — tags are <sc-string>, <sc-number>, ...
 * import { registerSchemaComponents } from "schema-components/lit/registry";
 * const tags = registerSchemaComponents();
 *
 * // Namespaced registration — tags are <myapp-sc-string>, ...
 * const namespaced = registerSchemaComponents("myapp-");
 * ```
 */
declare function registerSchemaComponents(prefix?: string): RegistrationResult;
/**
 * Return value of {@link registerSchemaComponents}.
 *
 * The `tags` map carries the canonical-tag → registered-tag mapping
 * for every built-in element. The default Lit resolver reads this map
 * to dispatch from a `WalkedField.type` to the matching Custom
 * Element tag — see `lit/renderers/defaultResolver.ts`.
 *
 * The `skipped` array lists tags that were already registered (a
 * second call to `registerSchemaComponents` with the same prefix, or
 * a deliberate consumer-side registration that pre-empted the
 * default). Skipped tags are NOT re-registered — the consumer's
 * implementation wins.
 */
interface RegistrationResult {
  tags: Readonly<Record<string, string>>;
  skipped: readonly string[];
}
//#endregion
export { BUILT_IN_ELEMENTS, RegistrationResult, registerSchemaComponents };