import { type Readable } from '@vielzeug/ripple';
export type PropsDef<T extends Record<string, unknown>> = {
    [K in keyof Required<T>]: PropDef<T[K & keyof T]>;
};
export type PropDef<T> = {
    readonly default: T;
    readonly parse: (value: string | null) => T;
    reflect?: boolean;
};
export type PropInputDefs = Record<string, PropDef<unknown>>;
/**
 * Prop definition factory — use these helpers for all prop definitions.
 * No implicit type inference; all parser behavior is explicit and intentional.
 */
type PropFactory = {
    bool(defaultValue?: boolean): PropDef<boolean>;
    /**
     * JS-only property — never reads from or writes to an HTML attribute.
     * Use for complex objects, arrays, callbacks, or any non-serialisable value.
     *
     * @example
     * ```ts
     * columns:   prop.data<DataGridColumn[]>([]),
     * config:    prop.data<Options>(),
     * getRowKey: prop.data<(row: T) => string>(),
     * onSelect:  prop.data<(item: T) => void>(),
     * ```
     */
    data<T>(): PropDef<T | undefined>;
    data<T>(defaultValue: T): PropDef<T>;
    json<T>(defaultValue: T): PropDef<T>;
    number<T extends number = number>(): PropDef<T | undefined>;
    number<T extends number = number>(defaultValue: number): PropDef<T>;
    oneOf<T extends string | undefined, D extends T = T>(allowed: readonly NonNullable<T>[], defaultValue: D): PropDef<T>;
    string<T extends string = string>(): PropDef<T | undefined>;
    string<T extends string = string>(defaultValue: string): PropDef<T>;
};
export declare const prop: PropFactory;
/**
 * Validate and normalize a prop definition.
 * Throws if definition is invalid or incomplete.
 *
 * Accepts any object shaped like `PropDef` — not just `prop.*` helper output — so you can
 * define a custom prop with explicit parser and reflection behavior when the `prop.*` helpers
 * don't cover your type:
 *
 * ```ts
 * const customProp = (): PropDef<MyCustomType> => ({
 *   default: new MyCustomType(),
 *   parse: (value) => JSON.parse(value || '{}') as MyCustomType,
 *   reflect: false,
 * });
 * ```
 */
export declare function normalizePropDefinition<T>(value: unknown, propName: string): PropDef<T>;
/**
 * Validate all prop definitions at define-time.
 * Returns validation error messages or empty array if valid.
 */
export declare function validatePropDefs(defs: Record<string, unknown>): string[];
/**
 * Look up the registered prop metadata for a given attribute name on an element.
 * Used by the template compiler to resolve prop bindings without exposing the registry.
 */
export declare const getPropMeta: (el: HTMLElement, attrName: string) => PropMeta<unknown> | undefined;
export type InferPropValue<T> = T extends PropDef<infer U> ? U : T;
/**
 * Infer the reactive props object type from a `PropInputDefs` map.
 * Each entry becomes a `Reactive<T>` keyed by the prop name.
 *
 * @example
 * ```ts
 * const propDefs = { count: prop.number(0), label: prop.string('hi') };
 * type Props = InferProps<typeof propDefs>;
 * // => { readonly count: Readable<number>; readonly label: Readable<string> }
 * ```
 */
export type InferProps<D extends PropInputDefs> = {
    readonly [K in keyof D]-?: Readable<InferPropValue<D[K]>>;
};
export declare function createProps<D extends PropInputDefs>(el: HTMLElement, defs: D): InferProps<D>;
export {};
//# sourceMappingURL=props.d.ts.map