/**
 * Hypen Tagged Template Literal
 *
 * Enables single-file components with inline UI templates.
 *
 * The `hypen` tagged template preserves ${state.x} and ${item.x} bindings
 * instead of interpolating them, allowing you to write:
 *
 * @example
 * ```typescript
 * import { app, hypen, state } from "@hypen-space/core";
 *
 * export default app
 *   .defineState({ count: 0 })
 *   .onAction("increment", ({ state }) => {
 *     state.count += 1;
 *   })
 *   .ui(hypen`
 *     Column {
 *       Text("Count: ${state.count}")
 *       Button { Text("+") }
 *         .onClick("@actions.increment")
 *     }
 *   `);
 * ```
 */
/**
 * Proxy for state bindings.
 *
 * Use in hypen templates to create reactive state bindings:
 *
 * @example
 * ```typescript
 * hypen`Text("Hello, ${state.user.name}")`
 * // Produces: Text("Hello, ${state.user.name}")
 * ```
 */
export declare const state: any;
/**
 * Proxy for item bindings in list iteration.
 *
 * Use inside List components to reference the current item:
 *
 * @example
 * ```typescript
 * hypen`
 *   List(@state.items) {
 *     Text("${item.name}: ${item.price}")
 *   }
 * `
 * ```
 */
export declare const item: any;
/**
 * Proxy for index in list iteration.
 *
 * Use inside List components to reference the current index:
 *
 * @example
 * ```typescript
 * hypen`
 *   List(@state.items) {
 *     Text("Item #${index}: ${item.name}")
 *   }
 * `
 * ```
 */
export declare const index: any;
/**
 * Tagged template literal for Hypen DSL templates.
 *
 * Works with the `state`, `item`, and `index` binding proxies to preserve
 * binding syntax in the output string.
 *
 * @example
 * ```typescript
 * import { hypen, state, item } from "@hypen-space/core";
 *
 * // Simple state binding
 * const t1 = hypen`Text("Count: ${state.count}")`;
 * // Result: 'Text("Count: ${state.count}")'
 *
 * // Nested state binding
 * const t2 = hypen`Text("Hello, ${state.user.profile.name}")`;
 * // Result: 'Text("Hello, ${state.user.profile.name}")'
 *
 * // List with item binding
 * const t3 = hypen`
 *   List(@state.products) {
 *     Text("${item.name} - $${item.price}")
 *   }
 * `;
 *
 * // Complex expressions (use regular JS interpolation for static values)
 * const title = "My App";
 * const t4 = hypen`Text("${title}: ${state.count}")`;
 * // Result: 'Text("My App: ${state.count}")'
 * ```
 *
 * @param strings - Template literal string parts
 * @param expressions - Interpolated expressions (proxies return binding strings)
 * @returns The template string with bindings preserved
 */
export declare function hypen(strings: TemplateStringsArray, ...expressions: unknown[]): string;
/**
 * Type helper for defining state shape.
 * Use with state proxy for better IDE support in complex scenarios.
 *
 * @example
 * ```typescript
 * type MyState = { user: { name: string; age: number } };
 * const typedState = state as StateProxy<MyState>;
 * ```
 */
export type StateProxy<T> = {
    [K in keyof T]: T[K] extends object ? StateProxy<T[K]> & {
        toString(): string;
    } : {
        toString(): string;
    };
} & {
    toString(): string;
};
/**
 * Type helper for item proxy in lists.
 */
export type ItemProxy<T> = StateProxy<T>;
