/**
 * JQHTML v2 Component Registry
 *
 * Global registry for component classes and templates
 * Enables dynamic component instantiation and template association
 */
import { Jqhtml_Component } from './component.js';
import { Jqhtml_Markup } from './markup.js';
export type TemplateFunction = (this: Jqhtml_Component, data: Record<string, any>, args: Record<string, any>, content: any, jqhtml?: any) => Jqhtml_Markup | {
    _slots: Record<string, (...args: any[]) => Jqhtml_Markup>;
};
export interface TemplateDefinition {
    name: string;
    tag: string;
    defaultAttributes?: Record<string, any>;
    extends?: string;
    render: TemplateFunction;
}
export type ComponentConstructor = new (args: Record<string, any>, element?: any) => Jqhtml_Component;
/**
 * Register a component class with optional template
 */
export declare function register_component(name: string, component_class: ComponentConstructor, template?: TemplateDefinition): void;
export declare function register_component(component_class: ComponentConstructor): void;
/**
 * Get a component class by name
 * If no class found, walks the template extends chain to find parent class
 */
export declare function get_component_class(name: string): ComponentConstructor | undefined;
/**
 * Register a template - name is extracted from template.name property
 * Returns true if registered, false if duplicate
 */
export declare function register_template(template_def: TemplateDefinition): boolean;
/**
 * Get template for a component by name
 */
export declare function get_template(name: string): TemplateDefinition;
/**
 * Check a template's `extends=""` against its component's JS class (CLAUDE.md "Template
 * Inheritance"). Returns an error message on conflict, null otherwise.
 *
 * The rule: list the class's JS ancestors up to Jqhtml_Component that have a template of
 * their own. An empty list (the class extends Jqhtml_Component directly, or only plain
 * helper classes sit in between) cannot conflict. Otherwise `extends=` must name one of
 * them - any ancestor, so a template may skip an intermediate layer. A template-only
 * component (no class registered under the template's name) and an `extends=` target
 * that has no template (resolution falls back to the prototype chain) are not conflicts.
 *
 * @param template_def The template being rendered
 * @param instance_class The rendering instance's class, used when no class is registered
 *   under the template's name but the instance's class carries that name
 */
export declare function extends_conflict(template_def: TemplateDefinition, instance_class?: any): string | null;
/**
 * Get template for a component class - walks up inheritance chain
 */
export declare function get_template_by_class(component_class: ComponentConstructor): TemplateDefinition;
/**
 * Create a component instance by name
 * If no component class is registered, uses the default Component class
 */
export declare function create_component(name: string, element?: any, args?: Record<string, any>): Jqhtml_Component;
/**
 * Check if a component is registered
 */
export declare function has_component(name: string): boolean;
/**
 * Get all registered component names
 */
export declare function get_component_names(): string[];
/**
 * Get all registered template names
 */
export declare function get_registered_templates(): string[];
/**
 * List all registered components with their template status
 */
export declare function list_components(): Record<string, {
    has_class: boolean;
    has_template: boolean;
}>;
/**
 * Unified registration function - auto-detects source type and delegates
 *
 * Accepts either:
 * - A compiled JQHTML template (has __jqhtml_template: true)
 * - A component class extending Jqhtml_Component (has static __jqhtml_component: true and static component_name)
 *
 * @param source - Compiled template or component class
 */
export declare function register(source: TemplateDefinition | ComponentConstructor): void;
//# sourceMappingURL=component-registry.d.ts.map