@public-ui/react-hook-form-adapter/dist/index.d.ts

React Hook Form adapter for KoliBri - The accessible HTML-Standard.

import React, { RefAttributes } from 'react';
import { Control } from 'react-hook-form';

declare namespace Common {
    type PrefixedKey<Prefix extends string, Key extends string> = `${Prefix}-${Key}`;
}

declare namespace Element {
    type Validators<R, O> = {
        readonly [Property in keyof R as `validate${Capitalize<string & Property>}`]: (newValue?: R[Property], oldValue?: R[Property]) => void;
    } & {
        readonly [Property in keyof O as `validate${Capitalize<string & Property>}`]: (newValue?: O[Property], oldValue?: O[Property]) => void;
    };
    type Mapper<R, O> = {
        readonly [Property in keyof R as `map${Capitalize<string & Property>}`]?: (newValue?: R[Property]) => R[Property];
    } & {
        readonly [Property in keyof O as `map${Capitalize<string & Property>}`]?: (newValue?: O[Property]) => O[Property];
    };
    type Watchers<R, O> = Validators<R, O> & Mapper<R, O>;
    type Props<P> = {
        [Property in keyof P as `_${string & Property}`]?: P[Property];
    };
    type Members<R, O> = {
        [Property in keyof R as `_${string & Property}`]: R[Property];
    } & {
        [Property in keyof O as `_${string & Property}`]?: O[Property];
    };
    type StateHooks = 'afterPatch' | 'beforePatch';
    type StateHooksCallback = (value: unknown, state: Record<string, unknown>, component: Component, key: string) => void;
    type NextStateHooksCallback = (nextValue: unknown, nextState: Map<string, unknown>, component: Component, key: string) => void;
    interface Component {
        componentWillLoad?: () => void;
        hydrated?: boolean;
        nextHooks?: Map<string, Map<StateHooks, StateHooksCallback | NextStateHooksCallback>>;
        nextState?: Map<string, unknown>;
        state: Record<string, unknown>;
        timeout?: number;
    }
    type ComponentApi<RequiredProps, OptionalProps, RequiredState, OptionalState> = Component & Members<RequiredProps, OptionalProps> & Watchers<RequiredProps, OptionalProps> & {
        readonly state: Members<RequiredState, OptionalState>;
    };
    type Stringified<T> = T | string;
}

declare namespace Locale {
    type ISO_639_1 = 'ab' | 'aa' | 'af' | 'ak' | 'sq' | 'am' | 'ar' | 'an' | 'hy' | 'as' | 'av' | 'ae' | 'ay' | 'az' | 'bm' | 'ba' | 'eu' | 'be' | 'bn' | 'bh' | 'bi' | 'nb' | 'bs' | 'br' | 'bg' | 'my' | 'es' | 'ca' | 'km' | 'ch' | 'ce' | 'ny' | 'zh' | 'za' | 'cu' | 'cv' | 'kw' | 'co' | 'cr' | 'hr' | 'cs' | 'da' | 'dv' | 'nl' | 'dz' | 'en' | 'eo' | 'et' | 'ee' | 'fo' | 'fj' | 'fi' | 'fr' | 'ff' | 'gd' | 'gl' | 'lg' | 'ka' | 'de' | 'ki' | 'el' | 'kl' | 'gn' | 'gu' | 'ht' | 'ha' | 'he' | 'hz' | 'hi' | 'ho' | 'hu' | 'is' | 'io' | 'ig' | 'id' | 'ia' | 'ie' | 'iu' | 'ik' | 'ga' | 'it' | 'ja' | 'jv' | 'kn' | 'kr' | 'ks' | 'kk' | 'rw' | 'ky' | 'kv' | 'kg' | 'ko' | 'kj' | 'ku' | 'lo' | 'la' | 'lv' | 'lb' | 'li' | 'ln' | 'lt' | 'lu' | 'mk' | 'mg' | 'ms' | 'ml' | 'mt' | 'gv' | 'mi' | 'mr' | 'mh' | 'ro' | 'mn' | 'na' | 'nv' | 'nd' | 'nr' | 'ng' | 'ne' | 'se' | 'no' | 'nn' | 'ii' | 'oc' | 'oj' | 'or' | 'om' | 'os' | 'pi' | 'pa' | 'ps' | 'fa' | 'pl' | 'pt' | 'qu' | 'rm' | 'rn' | 'ru' | 'sm' | 'sg' | 'sa' | 'sc' | 'sr' | 'sn' | 'sd' | 'si' | 'sk' | 'sl' | 'so' | 'st' | 'su' | 'sw' | 'ss' | 'sv' | 'tl' | 'ty' | 'tg' | 'ta' | 'tt' | 'te' | 'th' | 'bo' | 'ti' | 'to' | 'ts' | 'tn' | 'tr' | 'tk' | 'tw' | 'ug' | 'uk' | 'ur' | 'uz' | 've' | 'vi' | 'vo' | 'wa' | 'cy' | 'fy' | 'wo' | 'xh' | 'yi' | 'yo' | 'zu';
    type ISO_639_2 = 'abk' | 'ace' | 'ach' | 'ada' | 'ady' | 'aar' | 'afh' | 'afr' | 'afa' | 'ain' | 'aka' | 'akk' | 'alb/sqi' | 'gsw' | 'ale' | 'alg' | 'tut' | 'amh' | 'anp' | 'apa' | 'ara' | 'arg' | 'arp' | 'arw' | 'arm/hye' | 'rup' | 'art' | 'asm' | 'ast' | 'ath' | 'aus' | 'map' | 'ava' | 'ave' | 'awa' | 'aym' | 'aze' | 'ban' | 'bat' | 'bal' | 'bam' | 'bai' | 'bad' | 'bnt' | 'bas' | 'bak' | 'baq/eus' | 'btk' | 'bej' | 'bel' | 'bem' | 'ben' | 'ber' | 'bho' | 'bih' | 'bik' | 'byn' | 'bin' | 'bis' | 'zbl' | 'nob' | 'bos' | 'bra' | 'bre' | 'bug' | 'bul' | 'bua' | 'bur/mya' | 'cad' | 'spa' | 'cat' | 'cau' | 'ceb' | 'cel' | 'cai' | 'khm' | 'chg' | 'cmc' | 'cha' | 'che' | 'chr' | 'nya' | 'chy' | 'chb' | 'chi/zho' | 'chn' | 'chp' | 'cho' | 'zha' | 'chu' | 'chk' | 'chv' | 'nwc' | 'syc' | 'rar' | 'cop' | 'cor' | 'cos' | 'cre' | 'mus' | 'crp' | 'cpe' | 'cpf' | 'cpp' | 'crh' | 'hrv' | 'cus' | 'cze/ces' | 'dak' | 'dan' | 'dar' | 'del' | 'div' | 'zza' | 'din' | 'doi' | 'dgr' | 'dra' | 'dua' | 'dut/nld' | 'dum' | 'dyu' | 'dzo' | 'frs' | 'efi' | 'egy' | 'eka' | 'elx' | 'eng' | 'enm' | 'ang' | 'myv' | 'epo' | 'est' | 'ewe' | 'ewo' | 'fan' | 'fat' | 'fao' | 'fij' | 'fil' | 'fin' | 'fiu' | 'fon' | 'fre/fra' | 'frm' | 'fro' | 'fur' | 'ful' | 'gaa' | 'gla' | 'car' | 'glg' | 'lug' | 'gay' | 'gba' | 'gez' | 'geo/kat' | 'ger/deu' | 'nds' | 'gmh' | 'goh' | 'gem' | 'kik' | 'gil' | 'gon' | 'gor' | 'got' | 'grb' | 'grc' | 'gre/ell' | 'kal' | 'grn' | 'guj' | 'gwi' | 'hai' | 'hat' | 'hau' | 'haw' | 'heb' | 'her' | 'hil' | 'him' | 'hin' | 'hmo' | 'hit' | 'hmn' | 'hun' | 'hup' | 'iba' | 'ice/isl' | 'ido' | 'ibo' | 'ijo' | 'ilo' | 'arc' | 'smn' | 'inc' | 'ine' | 'ind' | 'inh' | 'ina' | 'ile' | 'iku' | 'ipk' | 'ira' | 'gle' | 'mga' | 'sga' | 'iro' | 'ita' | 'jpn' | 'jav' | 'kac' | 'jrb' | 'jpr' | 'kbd' | 'kab' | 'xal' | 'kam' | 'kan' | 'kau' | 'pam' | 'kaa' | 'krc' | 'krl' | 'kar' | 'kas' | 'csb' | 'kaw' | 'kaz' | 'kha' | 'khi' | 'kho' | 'kmb' | 'kin' | 'kir' | 'tlh' | 'kom' | 'kon' | 'kok' | 'kor' | 'kos' | 'kpe' | 'kro' | 'kua' | 'kum' | 'kur' | 'kru' | 'kut' | 'lad' | 'lah' | 'lam' | 'day' | 'lao' | 'lat' | 'lav' | 'ltz' | 'lez' | 'lim' | 'lin' | 'lit' | 'jbo' | 'dsb' | 'loz' | 'lub' | 'lua' | 'lui' | 'smj' | 'lun' | 'luo' | 'lus' | 'mac/mkd' | 'mad' | 'mag' | 'mai' | 'mak' | 'mlg' | 'may/msa' | 'mal' | 'mlt' | 'mnc' | 'mdr' | 'man' | 'mni' | 'mno' | 'glv' | 'mao/mri' | 'arn' | 'mar' | 'chm' | 'mah' | 'mwr' | 'mas' | 'myn' | 'men' | 'mic' | 'min' | 'mwl' | 'moh' | 'mdf' | 'rum/ron' | 'mkh' | 'lol' | 'mon' | 'cnr' | 'mos' | 'mul' | 'mun' | 'nqo' | 'nah' | 'nau' | 'nav' | 'nde' | 'nbl' | 'ndo' | 'nap' | 'new' | 'nep' | 'nia' | 'nic' | 'ssa' | 'niu' | 'zxx' | 'nog' | 'non' | 'nai' | 'frr' | 'sme' | 'nso' | 'nor' | 'nno' | 'nub' | 'iii' | 'nym' | 'nyn' | 'nyo' | 'nzi' | 'oci' | 'pro' | 'oji' | 'ori' | 'orm' | 'osa' | 'oss' | 'oto' | 'pal' | 'pau' | 'pli' | 'pag' | 'pan' | 'pap' | 'paa' | 'pus' | 'per/fas' | 'peo' | 'phi' | 'phn' | 'pon' | 'pol' | 'por' | 'pra' | 'que' | 'raj' | 'rap' | 'qaa-qtz' | 'roa' | 'roh' | 'rom' | 'run' | 'rus' | 'sal' | 'sam' | 'smi' | 'smo' | 'sad' | 'sag' | 'san' | 'sat' | 'srd' | 'sas' | 'sco' | 'sel' | 'sem' | 'srp' | 'srr' | 'shn' | 'sna' | 'scn' | 'sid' | 'sgn' | 'bla' | 'snd' | 'sin' | 'sit' | 'sio' | 'sms' | 'den' | 'sla' | 'slo/slk' | 'slv' | 'sog' | 'som' | 'son' | 'snk' | 'wen' | 'sot' | 'sai' | 'alt' | 'sma' | 'srn' | 'zgh' | 'suk' | 'sux' | 'sun' | 'sus' | 'swa' | 'ssw' | 'swe' | 'syr' | 'tgl' | 'tah' | 'tai' | 'tgk' | 'tmh' | 'tam' | 'tat' | 'tel' | 'ter' | 'tet' | 'tha' | 'tib/bod' | 'tig' | 'tir' | 'tem' | 'tiv' | 'tli' | 'tpi' | 'tkl' | 'tog' | 'ton' | 'tsi' | 'tso' | 'tsn' | 'tum' | 'tup' | 'tur' | 'ota' | 'tuk' | 'tvl' | 'tyv' | 'twi' | 'udm' | 'uga' | 'uig' | 'ukr' | 'umb' | 'mis' | 'und' | 'hsb' | 'urd' | 'uzb' | 'vai' | 'ven' | 'vie' | 'vol' | 'vot' | 'wak' | 'wln' | 'war' | 'was' | 'wel/cym' | 'fry' | 'wal' | 'wol' | 'xho' | 'sah' | 'yao' | 'yap' | 'yid' | 'yor' | 'ypk' | 'znd' | 'zap' | 'zen' | 'zul' | 'zun';
}

declare namespace I18n {
    export { Locale };
    export type Props<Prefix extends string, Key extends string> = Lowercase<Common.PrefixedKey<Prefix, Key>>;
    export type Map<Prefix extends string, Key extends string> = {
        [K in Props<Prefix, Key>]?: string;
    };
    export type Patch<Name extends Locale.ISO_639_1, Prefix extends string, Key extends string> = (name: Name, map: Map<Prefix, Key>) => Name;
    export type RegisterPatch<Name extends Locale.ISO_639_1, Prefix extends string, Key extends string> = (patch: Patch<Name, Prefix, Key>) => Name;
    export type Register<Name extends Locale.ISO_639_1, Prefix extends string, Key extends string> = (name: Name, map: Map<Prefix, Key>) => RegisterPatch<Name, Prefix, Key>;
}

declare namespace Theming {
    type PatchOptions = {
        append?: boolean;
    };
    type Props<Prefix extends string, Key extends string> = Uppercase<Common.PrefixedKey<Prefix, Key> | 'GLOBAL' | 'PROPERTIES'>;
    type Map<Prefix extends string, Key extends string> = {
        [K in Props<Prefix, Key>]?: string;
    };
    type Patch<Name extends string, Prefix extends string, Key extends string> = (name: Name, map: Map<Prefix, Key>, options?: PatchOptions) => Name;
    type RegisterPatch<Name extends string, Prefix extends string, Key extends string> = (patch: Patch<Name, Prefix, Key>) => Name;
    type Register<Name extends string, Prefix extends string, Key extends string> = (name: Name, map: Map<Prefix, Key>) => RegisterPatch<Name, Prefix, Key>;
}

declare namespace Generic {
    export type { Common, Element, I18n, Theming };
}

type Stringified<T> = string | T;

type AccessKeyPropType = string;
type PropAccessKey = {
    accessKey: AccessKeyPropType;
};

declare enum Callback$1 {
    onBlur = "onBlur",
    onChange = "onChange",
    onChangePage = "onChangePage",
    onClick = "onClick",
    onClose = "onClose",
    onDblClick = "onDblClick",
    onFocus = "onFocus",
    onInput = "onInput",
    onKeyDown = "onKeyDown",
    onKeyPress = "onKeyPress",
    onKeyUp = "onKeyUp",
    onMouseDown = "onMouseDown",
    onMouseMove = "onMouseMove",
    onMouseOut = "onMouseOut",
    onMouseOver = "onMouseOver",
    onMouseUp = "onMouseUp",
    onReset = "onReset",
    onSelect = "onSelect",
    onSelectionChange = "onSelectionChange",
    onChangePageSize = "onChangePageSize",
    onSort = "onSort",
    onSubmit = "onSubmit",
    onToggle = "onToggle"
}

type Callback<T> = (event: T) => void;
type EventCallback<E extends Event> = Callback<E>;
type EventValueCallback<E extends Event, V> = (event: E, value: V) => void;
type EventValueOrEventCallback<E extends Event, V> = EventValueCallback<E, V> | EventCallback<E>;

type AdjustHeightPropType = boolean;
type PropAdjustHeight = {
    adjustHeight: AdjustHeightPropType;
};

type AlertPropType = boolean;
type PropAlert = {
    alert: AlertPropType;
};

declare const alertTypeOptions: readonly ["default", "info", "success", "warning", "error"];
type AlertType = (typeof alertTypeOptions)[number];
type AlertTypePropType = AlertType;
type PropAlertType = {
    type: AlertTypePropType;
};

declare const horizontalAlignOptions: readonly ["left", "right"];
type HorizontalAlign = (typeof horizontalAlignOptions)[number];
declare const verticalAlignOptions: readonly ["top", "bottom"];
type VerticalAlign = (typeof verticalAlignOptions)[number];
type AlignPropType = HorizontalAlign | VerticalAlign;

declare const alternativeButtonLinkRolePropTypeOptions: readonly ["tab", "treeitem"];
type AlternativeButtonLinkRolePropType = (typeof alternativeButtonLinkRolePropTypeOptions)[number];
type PropAlternativeButtonLinkRole = {
    role: AlternativeButtonLinkRolePropType;
};

type AriaControlsPropType = string;
type PropAriaControls = {
    ariaControls: AriaControlsPropType;
};

type AriaDescriptionPropType = string;
type PropAriaDescription = {
    ariaDescription: AriaDescriptionPropType;
};

type AriaExpandedPropType = boolean;

type AriaSelectedPropType = boolean;
type PropAriaSelected = {
    ariaSelected: AriaSelectedPropType;
};

declare const autoCompleteOptions: readonly ["on", "off"];
type AutoCompletePropType = (typeof autoCompleteOptions)[number] | string;
type PropAutoComplete = {
    autoComplete: AutoCompletePropType;
};

type ShortKeyPropType = string;
type PropShortKey = {
    shortKey: ShortKeyPropType;
};

type StencilUnknown = object | string | number | boolean | null | undefined;

type ButtonCallbacksPropType<T> = {
    [Callback$1.onClick]?: EventValueOrEventCallback<MouseEvent, T>;
    [Callback$1.onMouseDown]?: EventCallback<MouseEvent>;
};
type PropButtonCallbacks<T> = {
    on: ButtonCallbacksPropType<T>;
};

declare const buttonTypePropTypeOptions: readonly ["button", "reset", "submit"];
type ButtonTypePropType = (typeof buttonTypePropTypeOptions)[number];
type PropButtonType = {
    type: ButtonTypePropType;
};

declare const buttonVariantPropTypeOptions: readonly ["primary", "secondary", "normal", "tertiary", "danger", "ghost", "custom"];
type ButtonVariantPropType = (typeof buttonVariantPropTypeOptions)[number];
type PropButtonVariant = {
    variant: ButtonVariantPropType;
};

type CheckedPropType = boolean;
type PropChecked = {
    checked: CheckedPropType;
};

type AnyIconFontClass = string;
type KoliBriCustomIcon = {
    icon: AnyIconFontClass;
    label?: string;
    style?: Record<string, string>;
};
type IconOrIconClass = AnyIconFontClass | KoliBriCustomIcon;
type KoliBriHorizontalIcons = {
    right?: IconOrIconClass;
    left?: IconOrIconClass;
};
type KoliBriVerticalIcons = {
    top?: IconOrIconClass;
    bottom?: IconOrIconClass;
};
type KoliBriHIcons = {
    icons?: KoliBriHorizontalIcons;
};
type KoliBriAllIcons = KoliBriHorizontalIcons & KoliBriVerticalIcons;
type KoliBriIconsProp = AnyIconFontClass | KoliBriAllIcons;
type KoliBriHorizontalIconsProp = AnyIconFontClass | KoliBriHorizontalIcons;

type Hour = `${number}`;
type Minute = `${number}`;
type Second = `${number}`;
type Year = `${number}`;
type Month = `${number}`;
type Day = `${number}`;
type CalendarWeek = `${number}`;
type IsoDate = `${Year}-${Month}-${Day}`;
type IsoTime = `${Hour}:${Minute}` | `${Hour}:${Minute}:${Second}`;
type IsoLocalDateTime = `${IsoDate}T${IsoTime}`;
type IsoMonth = `${Year}-${Month}`;
type IsoWeek = `${Year}-W${CalendarWeek}`;
type Iso8601 = IsoDate | IsoTime | IsoLocalDateTime | IsoMonth | IsoWeek;

type NumberString = `${number}` | `${number}.${number}`;

type InputTypeOnBlur = {
    [Callback$1.onBlur]?: EventCallback<Event>;
};
type InputTypeOnClick = {
    [Callback$1.onClick]?: EventCallback<Event>;
};
type InputTypeOnChange = {
    [Callback$1.onChange]?: EventValueOrEventCallback<Event, unknown>;
};
type InputTypeOnFocus = {
    [Callback$1.onFocus]?: EventCallback<Event>;
};
type InputTypeOnInput = {
    [Callback$1.onInput]?: EventValueOrEventCallback<Event, unknown>;
};
type Option<T> = {
    disabled?: boolean;
    label: string | number;
    value: T;
};
type RadioOption<T> = Option<T> & {
    hint?: string;
};
type Optgroup<T> = {
    disabled?: boolean;
    label: string;
    options: Option<T>[];
};
type SelectOption<T> = Option<T> | Optgroup<T> | RadioOption<T>;
type InputTypeOnDefault = InputTypeOnBlur & InputTypeOnClick & InputTypeOnChange & InputTypeOnFocus & InputTypeOnInput;

type W3CInputValue = string | number;

type CustomClassPropType = string;
type PropCustomClass = {
    customClass: CustomClassPropType;
};

type DisabledPropType = boolean;
type PropDisabled = {
    disabled: DisabledPropType;
};

type HasCloserPropType = boolean;
type PropHasCloser = {
    hasCloser: HasCloserPropType;
};

type HasCounterPropType = boolean;
type PropHasCounter = {
    hasCounter: HasCounterPropType;
};

type HideLabelPropType = boolean;
type PropHideLabel = {
    hideLabel: HideLabelPropType;
};

type HideMsgPropType = boolean;
type PropHideMsg = {
    hideMsg: HideMsgPropType;
};

type HintPropType = string;
type PropHint = {
    hint: HintPropType;
};

type IconsPropType = Stringified<KoliBriIconsProp>;
type IconsHorizontalPropType = Stringified<KoliBriHorizontalIconsProp>;
type PropIcons = {
    icons: IconsPropType;
};
type PropHorizontalIcons = {
    icons: IconsHorizontalPropType;
};

type InputCheckboxIconsProp = {
    checked: AnyIconFontClass;
    indeterminate?: AnyIconFontClass;
    unchecked?: AnyIconFontClass;
} | {
    checked?: AnyIconFontClass;
    indeterminate: AnyIconFontClass;
    unchecked?: AnyIconFontClass;
} | {
    checked?: AnyIconFontClass;
    indeterminate?: AnyIconFontClass;
    unchecked: AnyIconFontClass;
};
type InputCheckboxIconsState = {
    checked: AnyIconFontClass;
    indeterminate: AnyIconFontClass;
    unchecked: AnyIconFontClass;
};

type IdPropType = string;
type PropId = {
    id: IdPropType;
};

type IndeterminatePropType = boolean;
type PropIndeterminate = {
    indeterminate: IndeterminatePropType;
};

declare const headingLevelOptions: readonly [0, 1, 2, 3, 4, 5, 6];
type HeadingLevel = (typeof headingLevelOptions)[number];
type LabelPropType = string;
type LabelWithExpertSlotPropType = LabelPropType | '';
type PropLabel = {
    label: LabelPropType;
};
type PropLabelWithExpertSlot = {
    label: LabelWithExpertSlotPropType;
};

declare const labelAlignPropTypeOptions: readonly ["left", "right"];
type LabelAlignPropType = (typeof labelAlignPropTypeOptions)[number];
type PropLabelAlign = {
    labelAlign: LabelAlignPropType;
};

type RowsPropType = number;
type PropRows = {
    rows: RowsPropType;
};

declare const maxLengthBehaviorPropTypeOptions: readonly ["hard", "soft"];
type MaxLengthBehaviorPropType = (typeof maxLengthBehaviorPropTypeOptions)[number];
type PropMaxLengthBehavior = {
    maxLengthBehavior: MaxLengthBehaviorPropType;
};

type MsgPropType = Omit<AlertProps, '_label' | '_variant'> & {
    _description: string;
};
type PropMsg = {
    msg: Stringified<MsgPropType>;
};

type MultiplePropType = boolean;
type PropMultiple = {
    multiple: MultiplePropType;
};

type NamePropType = string;
type PropName = {
    name: NamePropType;
};

type OptionsPropType = Stringified<Option<StencilUnknown>[]>;
type OptionsWithOptgroupPropType = Stringified<(Option<StencilUnknown> | Optgroup<StencilUnknown>)[]>;
type RadioOptionsPropType = Stringified<RadioOption<StencilUnknown>[]>;
type PropOptions = {
    options: OptionsPropType;
};
type PropRadioOptions = {
    options: RadioOptionsPropType;
};
type PropOptionsWithOptgroup = {
    options: OptionsWithOptgroupPropType;
};

type PlaceholderPropType = string;

type ReadOnlyPropType = boolean;
type PropReadOnly = {
    readOnly: ReadOnlyPropType;
};

type RequiredPropType = boolean;
type PropRequired = {
    required: RequiredPropType;
};

type SpellCheckPropType = boolean;
type PropSpellCheck = {
    spellCheck: SpellCheckPropType;
};

type SuggestionsPropType = Stringified<W3CInputValue[]>;
type PropSuggestions = {
    suggestions: SuggestionsPropType;
};

type SyncValueBySelectorPropType = string;
type PropSyncValueBySelector = {
    syncValueBySelector: SyncValueBySelectorPropType;
};

type TooltipAlignPropType = AlignPropType;
type PropTooltipAlign = {
    tooltipAlign: TooltipAlignPropType;
};

type TouchedPropType = boolean;
type PropTouched = {
    touched: TouchedPropType;
};

declare const inputDateTypeOptions: readonly ["date", "datetime-local", "month", "time", "week"];
type InputDateTypePropType = (typeof inputDateTypeOptions)[number];

declare const inputTextTypeOptions: readonly ["text", "search", "url", "tel"];
type InputTextTypePropType = (typeof inputTextTypeOptions)[number];

declare const alertVariantOptions: readonly ["card", "msg"];
type AlertVariantPropType = (typeof alertVariantOptions)[number];
type PropAlertVariant = {
    variant: AlertVariantPropType;
};

declare const inputCheckboxVariantOptions: readonly ["button", "default", "switch"];
type InputCheckboxVariantPropType = (typeof inputCheckboxVariantOptions)[number];

type KoliBriAlertEventCallbacks = {
    onClose?: EventCallback<Event>;
};
type RequiredAlertProps = NonNullable<unknown>;
type OptionalAlertProps = {
    level: HeadingLevel;
    on: KoliBriAlertEventCallbacks;
} & PropLabel & PropAlert & PropHasCloser & PropAlertType & PropAlertVariant;
type AlertProps = Generic.Element.Members<RequiredAlertProps, OptionalAlertProps>;

type RequiredButtonProps = PropLabelWithExpertSlot;
type OptionalButtonProps = {
    tabIndex: number;
    value: StencilUnknown;
    ariaExpanded: AriaExpandedPropType;
} & PropAccessKey & PropAlternativeButtonLinkRole & PropAriaControls & PropAriaDescription & PropAriaSelected & PropButtonCallbacks<StencilUnknown> & PropButtonType & PropButtonVariant & PropCustomClass & PropDisabled & PropHideLabel & PropIcons & PropId & PropName & PropShortKey & PropSyncValueBySelector & PropTooltipAlign;
type ButtonProps = Generic.Element.Members<RequiredButtonProps, OptionalButtonProps>;

type RequiredProps$d = PropLabelWithExpertSlot & PropSuggestions;
type OptionalProps$d = {
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    placeholder: string;
    value: string;
} & PropAccessKey & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropName & PropRequired & PropShortKey & PropSyncValueBySelector & PropTouched;
type RequiredStates$d = {
    hasValue: boolean;
    suggestions: W3CInputValue[];
    value: string;
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$d = {
    on: InputTypeOnDefault;
    placeholder: string;
} & PropAccessKey & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropId & PropName & PropRequired & PropMsg & PropShortKey & PropTouched;
type ComboboxAPI = Generic.Element.ComponentApi<RequiredProps$d, OptionalProps$d, RequiredStates$d, OptionalStates$d>;

type RequiredProps$c = PropLabelWithExpertSlot;
type OptionalProps$c = {
    icons: Stringified<InputCheckboxIconsProp>;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    value: StencilUnknown;
    variant: InputCheckboxVariantPropType;
} & PropAccessKey & PropChecked & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropIndeterminate & PropName & PropRequired & PropShortKey & PropSyncValueBySelector & PropTouched & PropLabelAlign;
type RequiredStates$c = {
    icons: InputCheckboxIconsState;
    id: string;
    value: StencilUnknown;
    variant: InputCheckboxVariantPropType;
} & PropChecked & PropHideMsg & PropIndeterminate & PropLabelWithExpertSlot;
type OptionalStates$c = {
    on: InputTypeOnDefault;
} & PropAccessKey & PropDisabled & PropHideLabel & PropHint & PropMsg & PropName & PropRequired & PropShortKey & PropTouched & PropLabelAlign;
type InputCheckboxAPI = Generic.Element.ComponentApi<RequiredProps$c, OptionalProps$c, RequiredStates$c, OptionalStates$c>;

type RequiredProps$b = PropLabelWithExpertSlot;
type OptionalProps$b = {
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    smartButton: Stringified<ButtonProps>;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHideMsg & PropHint & PropHorizontalIcons & PropName & PropShortKey & PropSuggestions & PropSyncValueBySelector & PropTouched;
type RequiredStates$b = {
    id: string;
    suggestions: W3CInputValue[];
} & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$b = {
    on: InputTypeOnDefault;
    smartButton: ButtonProps;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropMsg & PropName & PropShortKey & PropTouched;
type InputColorAPI = Generic.Element.ComponentApi<RequiredProps$b, OptionalProps$b, RequiredStates$b, OptionalStates$b>;

type RequiredProps$a = PropLabelWithExpertSlot;
type OptionalProps$a = {
    max: Iso8601 | Date;
    min: Iso8601 | Date;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    smartButton: Stringified<ButtonProps>;
    step: number | NumberString;
    type: InputDateTypePropType;
    value: Iso8601 | Date | null;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHideMsg & PropHint & PropHorizontalIcons & PropName & PropReadOnly & PropRequired & PropSuggestions & PropTouched;
type RequiredStates$a = {
    hasValue: boolean;
    suggestions: W3CInputValue[];
    type: InputDateTypePropType;
} & PropLabelWithExpertSlot & PropHideMsg & PropId;
type OptionalStates$a = {
    max: Iso8601;
    min: Iso8601;
    on: InputTypeOnDefault;
    placeholder: string;
    smartButton: ButtonProps;
    step: number;
    value: Iso8601 | null;
} & PropAccessKey & PropAutoComplete & PropHint & PropSyncValueBySelector & PropDisabled & PropHideLabel & KoliBriHIcons & PropMsg & PropName & PropReadOnly & PropRequired & PropShortKey & PropTouched;
type InputDateAPI = Generic.Element.ComponentApi<RequiredProps$a, OptionalProps$a, RequiredStates$a, OptionalStates$a>;

type RequiredProps$9 = PropLabelWithExpertSlot;
type OptionalProps$9 = {
    maxLength: number;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: Stringified<ButtonProps>;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropMaxLengthBehavior & PropMultiple & PropName & PropReadOnly & PropRequired & PropShortKey & PropSuggestions & PropSyncValueBySelector & PropTouched;
type RequiredStates$9 = {
    hasValue: boolean;
    suggestions: W3CInputValue[];
    currentLength: number;
    currentLengthDebounced: number;
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$9 = {
    maxLength: number;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: ButtonProps;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropMaxLengthBehavior & PropMsg & PropMultiple & PropName & PropReadOnly & PropRequired & PropShortKey & PropTouched;
type InputEmailAPI = Generic.Element.ComponentApi<RequiredProps$9, OptionalProps$9, RequiredStates$9, OptionalStates$9>;

type RequiredProps$8 = PropLabelWithExpertSlot;
type OptionalProps$8 = {
    accept: string;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    smartButton: Stringified<ButtonProps>;
} & PropAccessKey & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropMultiple & PropName & PropRequired & PropShortKey & PropSyncValueBySelector & PropTouched;
type RequiredStates$8 = PropId & PropLabelWithExpertSlot & PropHideMsg;
type OptionalStates$8 = {
    accept: string;
    on: InputTypeOnDefault;
    smartButton: ButtonProps;
} & PropAccessKey & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropMsg & PropMultiple & PropName & PropRequired & PropShortKey & PropTouched;
type InputFileAPI = Generic.Element.ComponentApi<RequiredProps$8, OptionalProps$8, RequiredStates$8, OptionalStates$8>;

type RequiredProps$7 = PropLabelWithExpertSlot;
type OptionalProps$7 = {
    max: number | NumberString;
    min: number | NumberString;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    placeholder: PlaceholderPropType;
    smartButton: Stringified<ButtonProps>;
    step: number | NumberString;
    value: number | NumberString | null;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHideMsg & PropHint & PropHorizontalIcons & PropName & PropReadOnly & PropRequired & PropSuggestions & PropTouched;
type RequiredStates$7 = {
    hasValue: boolean;
    suggestions: W3CInputValue[];
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$7 = {
    max: number;
    min: number;
    on: InputTypeOnDefault;
    placeholder: PlaceholderPropType;
    smartButton: ButtonProps;
    step: number;
    value: number;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropMsg & PropName & PropReadOnly & PropRequired & PropSyncValueBySelector & PropShortKey & PropTouched;
type InputNumberAPI = Generic.Element.ComponentApi<RequiredProps$7, OptionalProps$7, RequiredStates$7, OptionalStates$7>;

declare const PasswordVariantPropTypeOptions: readonly ["default", "visibility-toggle"];
type PasswordVariantPropType = (typeof PasswordVariantPropTypeOptions)[number];
type PropPasswordVariant = {
    variant: PasswordVariantPropType;
};

type RequiredProps$6 = PropLabelWithExpertSlot;
type OptionalProps$6 = {
    maxLength: number;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: Stringified<ButtonProps>;
    value: string;
    msg: Stringified<MsgPropType>;
} & PropAccessKey & PropAutoComplete & PropPasswordVariant & PropDisabled & PropHasCounter & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropMaxLengthBehavior & PropName & PropReadOnly & PropRequired & PropShortKey & PropSyncValueBySelector & PropTouched;
type RequiredStates$6 = {
    currentLength: number;
    currentLengthDebounced: number;
    hasValue: boolean;
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$6 = {
    maxLength: number;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: ButtonProps;
    value: string | null;
} & PropAccessKey & PropAutoComplete & PropPasswordVariant & PropDisabled & PropHasCounter & PropHideLabel & PropHint & KoliBriHIcons & PropMaxLengthBehavior & PropMsg & PropName & PropReadOnly & PropRequired & PropShortKey & PropSyncValueBySelector & PropTouched;
type InputPasswordAPI = Generic.Element.ComponentApi<RequiredProps$6, OptionalProps$6, RequiredStates$6, OptionalStates$6>;

declare const orientationPropTypeOptions: readonly ["horizontal", "vertical"];
type OrientationPropType = (typeof orientationPropTypeOptions)[number];
type PropOrientation = {
    orientation: OrientationPropType;
};

type RequiredProps$5 = PropLabelWithExpertSlot;
type OptionalProps$5 = {
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    value: StencilUnknown;
} & PropDisabled & PropHideLabel & PropHideMsg & PropHint & PropName & PropOrientation & PropRadioOptions & PropRequired & PropSyncValueBySelector & PropTouched & PropTooltipAlign;
type RequiredStates$5 = {
    options: RadioOption<StencilUnknown>[];
} & PropId & PropHideMsg & PropLabelWithExpertSlot & PropOrientation;
type OptionalStates$5 = {
    on: InputTypeOnDefault;
    value: StencilUnknown;
} & PropDisabled & PropHideLabel & PropHint & PropMsg & PropName & PropRequired & PropTouched;
type InputRadioAPI = Generic.Element.ComponentApi<RequiredProps$5, OptionalProps$5, RequiredStates$5, OptionalStates$5>;

type RequiredProps$4 = PropLabelWithExpertSlot;
type OptionalProps$4 = {
    max: number | NumberString;
    min: number | NumberString;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    step: number | NumberString;
    value: number | NumberString;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropName & PropSuggestions & PropSyncValueBySelector & PropShortKey & PropTouched;
type RequiredStates$4 = {
    suggestions: W3CInputValue[];
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$4 = {
    max: number;
    min: number;
    on: InputTypeOnDefault;
    step: number;
    value: number;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropMsg & PropName & PropShortKey & PropTouched;
type InputRangeAPI = Generic.Element.ComponentApi<RequiredProps$4, OptionalProps$4, RequiredStates$4, OptionalStates$4>;

type RequiredProps$3 = PropLabelWithExpertSlot;
type OptionalProps$3 = {
    maxLength: number;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: Stringified<ButtonProps>;
    type: InputTextTypePropType;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHasCounter & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropId & PropMaxLengthBehavior & PropName & PropReadOnly & PropRequired & PropShortKey & PropSpellCheck & PropSuggestions & PropSyncValueBySelector & PropTouched;
type RequiredStates$3 = {
    currentLength: number;
    currentLengthDebounced: number;
    hasValue: boolean;
    suggestions: W3CInputValue[];
    type: InputTextTypePropType;
} & PropHideMsg & PropId & PropLabelWithExpertSlot;
type OptionalStates$3 = {
    maxLength: number;
    on: InputTypeOnDefault;
    pattern: string;
    placeholder: string;
    smartButton: ButtonProps;
    value: string;
} & PropAccessKey & PropAutoComplete & PropDisabled & PropHasCounter & PropHideLabel & PropHint & KoliBriHIcons & PropMaxLengthBehavior & PropMsg & PropName & PropReadOnly & PropRequired & PropShortKey & PropSpellCheck & PropTouched;
type InputTextAPI = Generic.Element.ComponentApi<RequiredProps$3, OptionalProps$3, RequiredStates$3, OptionalStates$3>;

type RequiredProps$2 = PropLabelWithExpertSlot & PropOptionsWithOptgroup;
type OptionalProps$2 = {
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    tabIndex: number;
    value: Stringified<StencilUnknown[]> | Stringified<StencilUnknown>;
} & PropAccessKey & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropMultiple & PropName & PropRequired & PropRows & PropShortKey & PropSyncValueBySelector & PropTouched;
type RequiredStates$2 = {
    hasValue: boolean;
    options: SelectOption<W3CInputValue>[];
    value: StencilUnknown[] | StencilUnknown;
} & PropId & PropHideMsg & PropMultiple & PropLabelWithExpertSlot;
type OptionalStates$2 = {
    on: InputTypeOnDefault;
    tabIndex: number;
} & PropAccessKey & PropDisabled & PropHideLabel & PropHint & KoliBriHIcons & PropId & PropName & PropRequired & PropRows & PropMsg & PropShortKey & PropTouched;
type SelectAPI = Generic.Element.ComponentApi<RequiredProps$2, OptionalProps$2, RequiredStates$2, OptionalStates$2>;

type RequiredProps$1 = PropLabelWithExpertSlot & PropOptions;
type OptionalProps$1 = {
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    placeholder: string;
    value: StencilUnknown;
    hideClearButton: boolean;
} & PropAccessKey & PropDisabled & PropHideMsg & PropHideLabel & PropHint & PropHorizontalIcons & PropName & PropRequired & PropRows & PropSyncValueBySelector & PropShortKey & PropTouched;
type RequiredStates$1 = {
    options: Option<StencilUnknown>[];
} & PropId & PropHideMsg & PropLabelWithExpertSlot;
type OptionalStates$1 = {
    on: InputTypeOnDefault;
    placeholder: string;
    hideClearButton: boolean;
} & PropAccessKey & PropDisabled & PropHideLabel & KoliBriHIcons & PropHint & PropId & PropName & PropRequired & PropRows & PropMsg & PropShortKey & PropTouched;
type SingleSelectAPI = Generic.Element.ComponentApi<RequiredProps$1, OptionalProps$1, RequiredStates$1, OptionalStates$1>;

declare const cssResizeOptions: readonly ["vertical", "none"];
type CSSResize = (typeof cssResizeOptions)[number];
type RequiredProps = PropLabelWithExpertSlot;
type OptionalProps = {
    maxLength: number;
    msg: Stringified<MsgPropType>;
    on: InputTypeOnDefault;
    placeholder: string;
    resize: CSSResize;
    value: string;
} & PropAccessKey & PropAdjustHeight & PropDisabled & PropHasCounter & PropHideLabel & PropHideMsg & PropHint & PropHorizontalIcons & PropId & PropMaxLengthBehavior & PropName & PropReadOnly & PropRequired & PropRows & PropShortKey & PropSpellCheck & PropSyncValueBySelector & PropTouched;
type RequiredStates = {
    adjustHeight: boolean;
    currentLength: number;
    currentLengthDebounced: number;
    hasValue: boolean;
    resize: CSSResize;
} & PropAdjustHeight & PropHideMsg & PropId & PropLabelWithExpertSlot;
type OptionalStates = {
    maxLength: number;
    on: InputTypeOnDefault;
    placeholder: string;
    value: string;
} & PropAccessKey & KoliBriHIcons & PropDisabled & PropHasCounter & PropHideLabel & PropHint & PropMaxLengthBehavior & PropMsg & PropName & PropReadOnly & PropRequired & PropRows & PropShortKey & PropSpellCheck & PropTouched;
type TextareaAPI = Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates>;

type ControllerBaseProps = {
    name: string;
    control: Control<any>;
    rules?: any;
    defaultValue?: any;
    shouldUnregister?: boolean;
    disabled?: boolean;
};
type ExtractProps<T> = T extends React.ComponentType<infer P> ? P : T extends React.ForwardRefExoticComponent<infer P> ? P : never;
type ControllerComponent<P> = React.ForwardRefExoticComponent<P & ControllerBaseProps & RefAttributes<HTMLElement>>;
declare function withController<T extends React.ComponentType<any>>(Component: T, valueProp?: string): ControllerComponent<ExtractProps<T>>;
declare const KolInputTextController: ControllerComponent<any>;
declare const KolInputPasswordController: ControllerComponent<any>;
declare const KolInputEmailController: ControllerComponent<any>;
declare const KolInputNumberController: ControllerComponent<any>;
declare const KolInputRangeController: ControllerComponent<any>;
declare const KolInputDateController: ControllerComponent<any>;
declare const KolInputColorController: ControllerComponent<any>;
declare const KolInputFileController: ControllerComponent<any>;
declare const KolTextareaController: ControllerComponent<any>;
declare const KolComboboxController: ControllerComponent<any>;
declare const KolSelectController: ControllerComponent<any>;
declare const KolSingleSelectController: ControllerComponent<any>;
declare const KolInputRadioController: ControllerComponent<any>;
declare const KolInputCheckboxController: ControllerComponent<any>;

export { KolComboboxController, KolInputCheckboxController, KolInputColorController, KolInputDateController, KolInputEmailController, KolInputFileController, KolInputNumberController, KolInputPasswordController, KolInputRadioController, KolInputRangeController, KolInputTextController, KolSelectController, KolSingleSelectController, KolTextareaController, withController };
export type { ComboboxAPI, InputCheckboxAPI, InputColorAPI, InputDateAPI, InputEmailAPI, InputFileAPI, InputNumberAPI, InputPasswordAPI, InputRadioAPI, InputRangeAPI, InputTextAPI, SelectAPI, SingleSelectAPI, TextareaAPI };