import { Context, Controller } from "@hotwired/stimulus";
declare class Wrapped<T extends object> {
    private _;
}
/**
 * Strongly type Object values
 * ```ts
 * const values = {
 *  address: Object_<{ street: string }>
 * }
 * ```
 */
export declare const Object_: typeof Wrapped;
export declare const ObjectAs: typeof Wrapped;
/**
 * Strongly type custom targets
 * ```ts
 * const targets = {
 *  select: Target<CustomSelect>
 * }
 * ```
 */
export declare const Target: typeof Wrapped;
/**
 * Identifier to camel case (admin--user-status to adminUserStatus)
 */
type CamelCase<K extends string> = K extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : K;
type ElementType<C> = C extends Controller<infer E> ? E : never;
type Singular<T, Suffix extends string> = {
    [K in keyof T as `${CamelCase<K & string>}${Suffix}`]: T[K];
};
type Existential<T, Suffix extends string> = {
    [K in keyof T as `has${Capitalize<CamelCase<K & string>>}${Suffix}`]: boolean;
};
type Plural<T, Suffix extends string> = {
    [K in keyof T as `${CamelCase<K & string>}${Suffix}s`]: T[K][];
};
type Elemental<T, Suffix extends string> = {
    [K in keyof T as `${CamelCase<K & string>}${Suffix}Element`]: ElementType<T[K]>;
} & {
    [K in keyof T as `${CamelCase<K & string>}${Suffix}Elements`]: ElementType<T[K]>[];
};
type Simplify<T> = {
    [KeyType in keyof T]: T[KeyType];
} & {};
type MagicProperties<T, Kind extends string> = (Kind extends "Value" ? Singular<T, Kind> : Readonly<Singular<T, Kind>>) & Readonly<Existential<T, Kind>> & Readonly<Kind extends "Target" | "Outlet" ? Plural<T, Kind> : unknown> & Readonly<Kind extends "Outlet" ? Elemental<T, Kind> : unknown>;
type Constructor<T = {}> = new (...args: any[]) => T;
type TypeFromConstructor<C> = C extends StringConstructor ? string : C extends NumberConstructor ? number : C extends BooleanConstructor ? boolean : C extends Constructor<infer T> ? T extends Wrapped<infer O> ? O : Object extends T ? unknown : T : never;
/**
 * Map `{ [key:string]: Constructor<T> } to { [key:string]: T }`
 */
type TransformType<T extends {}> = {
    [K in keyof T]: TypeFromConstructor<T[K]>;
};
/**
 * Transform `{ [key:string]: ValueTypeConstant | ValueTypeObject }`
 */
type TransformValueDefinition<T extends {}> = TransformType<{
    [K in keyof T]: T[K] extends {
        type: infer U;
    } ? U : T[K];
}>;
type ValueDefinitionMap = {
    [token: string]: ValueTypeDefinition;
};
type ValueTypeConstant = typeof Array<any> | typeof Boolean | typeof Number | typeof Object | typeof String | typeof Object_;
type ValueTypeDefault = Array<any> | boolean | number | Object | typeof Object_ | string;
type ValueTypeObject = Partial<{
    type: ValueTypeConstant;
    default: ValueTypeDefault;
}>;
type ValueTypeDefinition = ValueTypeConstant | ValueTypeObject;
type TargetDefinitionMap = {
    [token: string]: typeof Element | typeof Target;
};
type OutletDefinitionMap = {
    [token: string]: Constructor<Controller>;
};
type Statics<Values extends ValueDefinitionMap, Targets extends TargetDefinitionMap, Outlets extends OutletDefinitionMap> = {
    values?: Values;
    targets?: Targets;
    outlets?: Outlets;
};
type StimulusProperties<Values extends ValueDefinitionMap, Targets extends TargetDefinitionMap, Outlets extends OutletDefinitionMap> = Simplify<MagicProperties<TransformValueDefinition<Values>, "Value"> & MagicProperties<TransformType<Targets>, "Target"> & MagicProperties<TransformType<Outlets>, "Outlet">>;
/**
 * Strongly typed Controller!
 * ```ts
 * const values = {
 *  name: String,
 *  alias: Array<string>,
 *  address: Object_<{ street: string }>
 * }
 * const targets = { form: HTMLFormElement, "select": Target<CustomSelect> }
 * const outlets = { "user-status": UserStatusController }
 *
 * class MyController extends Typed(Controller, { values, targets, outlets }) {
 *  // Look Ma, no "declare ..."
 *  this.nameValue.split(' ')
 *  this.aliasValue.map(alias => alias.toUpperCase())
 *  this.addressValue.street
 *  this.formTarget.submit()
 *  this.selectTarget.search = "stimulus";
 *  this.userStatusOutlets.forEach(status => status.markAsSelected(event))
 * }
 * ```
 */
export declare function Typed<Values extends ValueDefinitionMap, Targets extends TargetDefinitionMap, Outlets extends OutletDefinitionMap, Base extends Constructor<Controller>>(Base: Base, statics: Statics<Values, Targets, Outlets>): new (context: Context) => InstanceType<Base> & StimulusProperties<Values, Targets, Outlets>;
export {};