import { LuminaPropertyDeclaration } from './controllers/types.ts';
export { state } from 'lit/decorators/state.js';
/**
 * A class field or accessor decorator which creates a reactive property that
 * reflects a corresponding attribute value. When a decorated property is set
 * the element will update and render.
 *
 * This decorator should only be used for public fields. As public fields,
 * properties should be considered as primarily settable by element users,
 * either via attribute or the property itself.
 *
 * Generally, properties that are changed by the element should be private or
 * protected fields and should use the `state()` decorator.
 *
 * However, sometimes element code does need to set a public property. This
 * should typically only be done in response to user interaction, and an event
 * should be fired informing the user; for example, a checkbox sets its
 * `checked` property when clicked and fires a `changed` event. Mutating public
 * properties should typically not be done for non-primitive (object or array)
 * properties. In other cases when an element needs to manage state, a private
 * property decorated via the `state()` decorator should be used. When
 * needed, state properties can be initialized via public properties to
 * facilitate complex interactions.
 *
 * @example
 *
 * ```ts
 * class MyElement {
 *   \@property()
 *   clicked = false;
 * }
 * ```
 *
 * @example
 * Declaring a readOnly property:
 *
 * ```ts
 * class MyElement {
 *   \@property({ readOnly: true })
 *   state: State = "loading";
 * }
 * ```
 */
export declare const property: (options?: Omit<LuminaPropertyDeclaration, "state">) => PropertyDecorator;
declare type CustomMethodDecorator<T> = (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
/**
 * The `@method()` decorator is used to expose methods on the public API.
 * Class methods decorated with the `@method()` decorator can be called directly
 * from the element, meaning they are intended to be callable from the outside.
 *
 * @remarks
 * This decorator does not exist at runtime and is only used as a hint for the
 * compiler to declare certain methods as public.
 */
export declare const method: () => CustomMethodDecorator<(...args: never[]) => any>;