@vueland/ui 0.0.1 → 0.0.3

package/dist/components/index.d.ts

@@ -1,19 +1,5 @@
 import * as vue from 'vue';
-import { VNode, Component, FunctionalComponent, PropType } from 'vue';
-
-declare var __VLS_1$4: {};
-type __VLS_Slots$8 = {} & {
-    default?: (props: typeof __VLS_1$4) => any;
-};
-declare const __VLS_component$8: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-declare const _default$j: __VLS_WithSlots$8<typeof __VLS_component$8, __VLS_Slots$8>;
-
-type __VLS_WithSlots$8<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-//# sourceMappingURL=CApp.vue.d.ts.map
+import { VNode, ComponentPublicInstance, VNodeChild, PropType, Component, FunctionalComponent, ComputedRef } from 'vue';
 
 type ApplicationApi = {
     blockScroll(): void;
@@ -21,37 +7,20 @@ type ApplicationApi = {
     getScrollTop(): number;
     getScrollLeft(): number;
 };
-
-type Maybe<T> = T | undefined;
-
-interface DimensionsProps {
-    width?: number | string;
-    height?: number | string;
-    minWidth?: number | string;
-    maxWidth?: number | string;
-    minHeight?: number | string;
-    maxHeight?: number | string;
-}
-
-type InputStateProps = {
-    disabled?: boolean;
-    focused?: boolean;
-    readonly?: boolean;
+type CAppSlots = {
+    default(): VNode | VNode[];
 };
 
-type ValidateFn = (value: any) => ({
-    valid: boolean;
-    message: string;
-});
-type ValidateOn = 'input' | 'blur';
-type ValidateProps = {
-    rules?: ValidateFn[];
-    validateOn?: ValidateOn;
-};
-type ValidateState = {
-    errorMessage: Maybe<string>;
-    hasError: boolean;
+type __VLS_Slots$b = CAppSlots;
+declare const __VLS_component$b: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const _default$l: __VLS_WithSlots$b<typeof __VLS_component$b, __VLS_Slots$b>;
+
+type __VLS_WithSlots$b<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };
+//# sourceMappingURL=CApp.vue.d.ts.map
 
 type ActivatorProps = {
     closeOnClick?: boolean;
@@ -59,6 +28,7 @@ type ActivatorProps = {
     openOnHover?: boolean;
     closeOnLeave?: boolean;
     openOnFocus?: boolean;
+    activator?: ComponentPublicInstance | Element;
 };
 type ActivatorListeners = {
     mouseenter?: (e: Event) => void;
@@ -73,128 +43,159 @@ type ActivatorListeners = {
     change?: (e: Event) => void;
 };
 
-interface PositionProps {
-    left?: boolean;
-    right?: boolean;
-    top?: boolean;
-    bottom?: boolean;
+interface DimensionsProps {
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
 }
 
-type DelayProps = {
-    openDelay?: number | string;
-    closeDelay?: number | string;
-};
+type Maybe<T> = T | undefined;
 
-interface CoordsProps {
+type AlignSide = 'top' | 'bottom' | 'left' | 'right';
+type AlignValue$1 = AlignSide | 'top-center' | 'top-left' | 'top-right' | 'bottom-center' | 'bottom-left' | 'bottom-right' | 'left-center' | 'right-center';
+interface AutoPositionProps {
+    strategy?: 'reverse' | 'bounce';
     positionX?: number;
     positionY?: number;
     offsetX?: number | string;
     offsetY?: number | string;
-}
-interface AutoPositionProps {
-    strategy?: 'reverse' | 'bounce';
+    align?: AlignValue$1;
 }
 
-type PresetProps = {
-    preset?: string;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+type Path<T> = T extends Primitive ? never : T extends readonly unknown[] ? never : T extends object ? {
+    [K in keyof T & string]: T[K] extends Primitive ? K : K | `${K}.${Path<T[K]>}`;
+}[keyof T & string] : never;
+type LoosePath<T> = Path<T> | (string & {});
+type IterableItemsProps<T> = {
+    items: readonly T[];
+    titleKey?: LoosePath<T>;
+    valueKey?: LoosePath<T>;
+};
+type NormalizedItem<T> = {
+    raw: T;
+    title: unknown;
+    value: unknown;
+    key: string;
+};
+
+type SelectableProps<T> = {
+    modelValue: T | T[];
+    multiple?: boolean;
+    mandatory?: boolean;
 };
 
 type CBtnProps = PresetProps & {
     variant?: 'flat' | 'outlined';
     block?: boolean;
+    disabled?: boolean;
 };
 
-declare var __VLS_1$3: {};
-type __VLS_Slots$7 = {} & {
-    default?: (props: typeof __VLS_1$3) => any;
+declare var __VLS_1$5: {};
+type __VLS_Slots$a = {} & {
+    default?: (props: typeof __VLS_1$5) => any;
 };
-declare const __VLS_component$7: vue.DefineComponent<CBtnProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<CBtnProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$i: __VLS_WithSlots$7<typeof __VLS_component$7, __VLS_Slots$7>;
+declare const __VLS_component$a: vue.DefineComponent<CBtnProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    click: (e: MouseEvent) => any;
+}, string, vue.PublicProps, Readonly<CBtnProps> & Readonly<{
+    onClick?: ((e: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$k: __VLS_WithSlots$a<typeof __VLS_component$a, __VLS_Slots$a>;
 
-type __VLS_WithSlots$7<T, S> = T & {
+type __VLS_WithSlots$a<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
 //# sourceMappingURL=CBtn.vue.d.ts.map
 
-declare function validate(): Promise<boolean>;
-declare var __VLS_1$2: {
-    validate: typeof validate;
-};
-type __VLS_Slots$6 = {} & {
-    default?: (props: typeof __VLS_1$2) => any;
+type DelayProps = {
+    openDelay?: number | string;
+    closeDelay?: number | string;
 };
-declare const __VLS_component$6: vue.DefineComponent<{}, {
-    validate: typeof validate;
-}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-declare const _default$h: __VLS_WithSlots$6<typeof __VLS_component$6, __VLS_Slots$6>;
 
-type __VLS_WithSlots$6<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-//# sourceMappingURL=CForm.vue.d.ts.map
+type IconMode = 'sprite' | 'component' | 'raw' | 'fa' | 'md';
 
-type ValidatorFn = () => boolean;
-interface FormApi {
-    add(fn: ValidatorFn): void;
-    remove(fn: ValidatorFn): void;
+interface InputState {
+    focused: boolean;
+    isDirty: boolean;
 }
-type FormSlots = {
-    default(props: {
-        validate: ValidatorFn;
-    }): VNode;
-};
-
-type CInputProps<T = any> = ValidateProps & InputStateProps & PresetProps & {
+type CInputRole = 'combobox' | 'checkbox' | 'radio' | 'listbox';
+type CInputProps<T = any> = ValidateProps & PresetProps & {
     id?: string;
-    modelValue: T;
+    modelValue: T | T[] | undefined | null;
     label?: string;
     details?: string;
     noDetails?: boolean;
     clearable?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+    readonly?: boolean;
+    role?: CInputRole;
+};
+type CInputEmits<T = any> = {
+    (e: 'update:modelValue', value: T): void;
+    (e: 'update:focused', value: boolean): void;
+};
+type CInputDetailsSlotProps = {
+    errorMessage: ValidateState['errorMessage'];
+    hasError: ValidateState['hasError'];
+    validating: ValidateState['validating'];
+    uid: string;
+    details?: string;
+};
+type CInputFieldSlotProps = {
+    focus(): void;
+    blur(): void;
+    reset(): void;
+    label?: string;
+    focused: boolean;
+    clearable?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    preset?: string;
+    errorMessage: ValidateState['errorMessage'];
+    hasError: ValidateState['hasError'];
+    validating: ValidateState['validating'];
+    attrs: Record<string, unknown>;
+    uid: string;
+    validate(): boolean | Promise<boolean>;
 };
 type CInputSlots = {
-    label?(props: {
-        uid: string;
-    }): VNode | string;
-    prepend?(): VNode | string;
-    append?(): VNode | string;
-    details?(props: {
-        errorMessage: ValidateState['errorMessage'];
-        hasError: ValidateState['hasError'];
-        uid: string;
-    }): VNode | string;
-    field?(props: {
-        onInput(): void;
-        onFocus(): void;
-        onBlur(): void;
+    details?(props: CInputDetailsSlotProps): VNode | string;
+    field?(props: CInputFieldSlotProps): VNode;
+};
+
+declare const _default$j: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$7<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal$7<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        readonly "onUpdate:focused"?: ((value: boolean) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:focused"> & (ValidateProps & PresetProps & {
+        id?: string;
+        modelValue: T | T[] | null | undefined;
         label?: string;
+        details?: string;
+        noDetails?: boolean;
+        clearable?: boolean;
+        disabled?: boolean;
+        focused?: boolean;
         readonly?: boolean;
+        role?: CInputRole;
+    } & {
         focused?: boolean;
-        disabled?: boolean;
-        presets?: string[] | string[][];
-        errorMessage: ValidateState['errorMessage'];
-        hasError: ValidateState['hasError'];
-        attrs: Record<string, any>;
-        uid: string;
-        validate(): boolean;
-    }): VNode;
-};
-
-declare const _default$g: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$7<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal$7<Pick<Partial<{}> & Omit<{} & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, never> & CInputProps<T> & Partial<{}>> & vue.PublicProps;
+    }) & Partial<{}>> & vue.PublicProps;
     expose(exposed: vue.ShallowUnwrapRef<{
-        validate: () => boolean;
-        onFocus: () => void;
-        onBlur: () => void;
-        onInput: () => void;
+        validate: () => Promise<boolean>;
+        focus: () => void;
+        blur: () => void;
+        reset: () => void;
     }>): void;
     attrs: any;
     slots: CInputSlots;
-    emit: {};
+    emit: CInputEmits<T> & ((evt: "update:focused", value: boolean) => void);
 }>) => vue.VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
@@ -204,68 +205,61 @@ type __VLS_PrettifyLocal$7<T> = {
 } & {};
 //# sourceMappingURL=CInput.vue.d.ts.map
 
-type __VLS_PublicProps$4 = {
-    modelValue?: string | number;
+type ValidateResult = {
+    valid: boolean;
+    message: string;
 };
-declare var __VLS_17: string | number;
-declare var __VLS_18: any;
-type __VLS_Slots$5 = {} & {
-    [K in NonNullable<typeof __VLS_17>]?: (props: typeof __VLS_18) => any;
+type ValidateFn = (value: any) => ValidateResult | Promise<ValidateResult>;
+type ValidateOn = 'input' | 'blur';
+type ValidateProps = {
+    rules?: ValidateFn[];
+    validateOn?: ValidateOn;
 };
-declare const __VLS_component$5: vue.DefineComponent<__VLS_PublicProps$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    "update:modelValue": (value: string | number | undefined) => any;
-}, string, vue.PublicProps, Readonly<__VLS_PublicProps$4> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$f: __VLS_WithSlots$5<typeof __VLS_component$5, __VLS_Slots$5>;
-
-type __VLS_WithSlots$5<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
+type ValidateState = {
+    errorMessage: Maybe<string>;
+    hasError: boolean;
+    validating: boolean;
 };
-//# sourceMappingURL=CTextField.vue.d.ts.map
 
-type __VLS_Props$4 = {
-    tag?: 'input' | 'textarea';
-    focused?: boolean;
-};
-type __VLS_PublicProps$3 = __VLS_Props$4 & {
-    modelValue?: string | number | undefined;
+type PresetProps = {
+    preset?: string;
 };
-declare const _default$e: vue.DefineComponent<__VLS_PublicProps$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    "update:modelValue": (value: string | number | undefined) => any;
-} & {
-    focus: () => any;
-}, string, vue.PublicProps, Readonly<__VLS_PublicProps$3> & Readonly<{
-    onFocus?: (() => any) | undefined;
-    "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-//# sourceMappingURL=CField.vue.d.ts.map
 
-type CAutocompleteProps<T> = {
-    modelValue: T | T[];
-    items: T[];
-    multiple?: boolean;
+type CAutocompleteProps<T> = IterableItemsProps<T> & SelectableProps<T> & {
     options?: {
-        extKey?: string;
         noItemsMessage?: string;
         menuPreset?: string;
     };
 };
 type CAutocompleteSlots<T> = {
     menu(props: {
-        items: T[];
+        items: NormalizedItem<T>[];
         onSelect(val: T): void;
     }): void;
+    field: CInputSlots['field'];
+    prepend(): VNode;
+    append(): VNode;
+    chips(props: {
+        items: T[];
+    }): VNode[];
+    details(props: {
+        errorMessage?: string;
+        details?: string;
+    }): VNode;
     ['no-items-message'](): string;
 };
+type CAutocompletePublicProps<T> = CInputProps<T> & CAutocompleteProps<T>;
 
-declare const _default$d: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$6<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const _default$i: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$6<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal$6<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
         readonly "onUpdate:search"?: ((val: string) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:search"> & (CAutocompleteProps<T> & {
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:search"> & (IterableItemsProps<T> & SelectableProps<T> & {
+        options?: {
+            noItemsMessage?: string;
+            menuPreset?: string;
+        };
+    } & {
         modelValue?: T | T[];
     }) & Partial<{}>> & vue.PublicProps;
     expose(exposed: vue.ShallowUnwrapRef<{}>): void;
@@ -281,33 +275,43 @@ type __VLS_PrettifyLocal$6<T> = {
 } & {};
 //# sourceMappingURL=CAutocomplete.vue.d.ts.map
 
-type CSelectProps<T> = {
-    modelValue: T | T[];
-    items: T[];
+declare const CCard: vue.FunctionalComponent<{}, {}, any, {}>;
+declare const CCardHeader: vue.FunctionalComponent<{}, {}, any, {}>;
+declare const CCardBody: vue.FunctionalComponent<{}, {}, any, {}>;
+declare const CCardFooter: vue.FunctionalComponent<{}, {}, any, {}>;
+
+interface CSelectControlProps<T = any> {
+    modelValue: T | T[] | boolean;
+    value?: T;
     multiple?: boolean;
-    options?: {
-        extKey?: string;
-        noItemsMessage?: string;
-    };
-};
-type CSelectSlots<T> = {
-    menu(props: {
-        items: T[];
-        onSelect(item: T): void;
-    }): void;
-    ['no-items-message'](): string;
-};
+    focused?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    name?: string;
+}
+interface CSelectControlSlots {
+    default(props: {
+        checked: boolean;
+        disabled: boolean;
+        readonly: boolean;
+        toggle: () => void;
+    }): VNode;
+}
 
-declare const _default$c: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$5<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const _default$h: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$5<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal$5<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (CSelectProps<T> & {
-        modelValue?: T | T[];
+        readonly "onUpdate:modelValue"?: ((value: boolean | T | T[]) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (CSelectControlProps<any> & {
+        modelValue?: T | T[] | boolean;
     }) & Partial<{}>> & vue.PublicProps;
-    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
+    expose(exposed: vue.ShallowUnwrapRef<{
+        checkOn: () => void;
+        checkOff: () => void;
+        toggle: () => void;
+    }>): void;
     attrs: any;
-    slots: CSelectSlots<T>;
-    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: CSelectControlSlots;
+    emit: (evt: "update:modelValue", value: boolean | T | T[]) => void;
 }>) => vue.VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
@@ -315,240 +319,519 @@ declare const _default$c: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setu
 type __VLS_PrettifyLocal$5<T> = {
     [K in keyof T]: T[K];
 } & {};
-//# sourceMappingURL=CSelect.vue.d.ts.map
+//# sourceMappingURL=CSelectControl.vue.d.ts.map
 
-type COverlayProps = {
-    modelValue: boolean;
-    to?: string;
+type CCheckboxModel<T> = T | T[] | boolean;
+type CCheckboxProps<T> = {
+    modelValue: CCheckboxModel<T>;
+    value?: T;
+    size?: number;
 };
-type COverlaySlots = {
-    default?(props: {
-        zIndex: number;
+type CCheckboxSlots = {
+    icon(props: {
+        checked: boolean;
     }): VNode;
+    default(): VNode;
+};
+type CCheckboxEvents<T> = {
+    (e: 'update:modelValue', value: T): void;
 };
+type CCheckboxPublicProps<T> = CCheckboxProps<T> & CSelectControlProps<T> & CInputProps<CCheckboxModel<T>>;
 
-type __VLS_Props$3 = COverlayProps;
-type __VLS_Slots$4 = COverlaySlots;
-type __VLS_PublicProps$2 = __VLS_Props$3 & {
-    modelValue?: boolean;
+declare const _default$g: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal$4<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (CCheckboxProps<T> & {
+        modelValue?: T;
+    }) & Partial<{}>> & vue.PublicProps;
+    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: CCheckboxSlots;
+    emit: (evt: "update:modelValue", value: T | undefined) => void;
+}>) => vue.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
 };
-declare const __VLS_component$4: vue.DefineComponent<__VLS_PublicProps$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
-}, string, vue.PublicProps, Readonly<__VLS_PublicProps$2> & Readonly<{
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$b: __VLS_WithSlots$4<typeof __VLS_component$4, __VLS_Slots$4>;
 
-type __VLS_WithSlots$4<T, S> = T & {
+type __VLS_PrettifyLocal$4<T> = {
+    [K in keyof T]: T[K];
+} & {};
+//# sourceMappingURL=CCheckbox.vue.d.ts.map
+
+declare var __VLS_1$4: {};
+type __VLS_Slots$9 = {} & {
+    default?: (props: typeof __VLS_1$4) => any;
+};
+declare const __VLS_component$9: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const _default$f: __VLS_WithSlots$9<typeof __VLS_component$9, __VLS_Slots$9>;
+
+type __VLS_WithSlots$9<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-//# sourceMappingURL=COverlay.vue.d.ts.map
+//# sourceMappingURL=CChip.vue.d.ts.map
+
+type DatePickerDate = {
+    year: number;
+    month: number;
+    date: number | null;
+    day: number;
+    mls?: number;
+    isHoliday?: boolean;
+    isHighlighted?: boolean;
+};
+type DisabledDates = {
+    daysOfMonth?: number[];
+    from?: Date | string;
+    to?: Date | string;
+    dates?: (Date | string)[];
+    days?: number[];
+    ranges?: Array<{
+        from: Date | string;
+        to: Date | string;
+    }>;
+    custom?: (date: DatePickerDate) => boolean;
+};
+
+type EnrichedDate = {
+    dateObj: DatePickerDate | null;
+    empty: boolean;
+    disabled: boolean;
+    highlighted: boolean;
+    isSelected: boolean;
+    isToday: boolean;
+};
+
+type EnrichedMonth = {
+    month: number;
+    label: string;
+    disabled: boolean;
+    isSelected: boolean;
+    isCurrent: boolean;
+    onSelect: () => void;
+};
+
+type EnrichedYear = {
+    year: number;
+    disabled: boolean;
+    isSelected: boolean;
+    isCurrent: boolean;
+    onSelect: () => void;
+};
+
+type __VLS_Slots$8 = {
+    'before-header'?(props: DatePickerSlotApi): VNodeChild;
+    header?(props: DatePickerSlotApi): VNodeChild;
+    'before-body'?(props: DatePickerSlotApi): VNodeChild;
+    body?(props: DatePickerSlotApi): VNodeChild;
+    footer?(props: DatePickerSlotApi): VNodeChild;
+    week?(props: {
+        days: DatePickerWeekDay[];
+    }): VNodeChild;
+    dates?(props: {
+        dates: EnrichedDate[];
+        onSelect: (d: DatePickerDate) => void;
+    }): any;
+    date?(props: DatePickerDate & {
+        isSelected: boolean;
+        isToday: boolean;
+    }): VNodeChild;
+    months?(props: {
+        months: EnrichedMonth[];
+    }): VNodeChild;
+    month?(props: EnrichedMonth): VNodeChild;
+    years?(props: {
+        years: EnrichedYear[];
+    }): VNodeChild;
+    year?(props: EnrichedYear): VNodeChild;
+};
+declare const enum ViewMode {
+    DATES = 0,
+    MONTHS = 1,
+    YEARS = 2
+}
+type DatePickerSlotApi = {
+    view: ViewMode;
+    value: string;
+    selected: DatePickerDate;
+    disablePrev: boolean;
+    disableNext: boolean;
+    onNext: () => void;
+    onPrev: () => void;
+    onTable: () => void;
+    onToday: () => void;
+};
+type DatePickerWeekDay = {
+    day: number;
+    label: string | undefined;
+};
+type DatePickerEnrichedDate = EnrichedDate;
+type DatePickerEnrichedMonth = EnrichedMonth;
+type DatePickerEnrichedYear = EnrichedYear;
+type CDatePickerProps = {
+    modelValue?: Date | string | null;
+    lang?: string;
+    format?: string;
+    mondayFirst?: boolean;
+    disabledDates?: DisabledDates;
+    highlightedDates?: (Date | string)[];
+    minDate?: Date | string;
+    maxDate?: Date | string;
+};
+declare const __VLS_component$8: vue.DefineComponent<CDatePickerProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "update:modelValue": (value: Date | null) => any;
+    selected: (value: Date | null) => any;
+}, string, vue.PublicProps, Readonly<CDatePickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
+    onSelected?: ((value: Date | null) => any) | undefined;
+}>, {
+    lang: string;
+    format: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$e: __VLS_WithSlots$8<typeof __VLS_component$8, __VLS_Slots$8>;
 
-type CMenuProps = ActivatorProps & CoordsProps & DimensionsProps & PositionProps & AutoPositionProps & DelayProps & PresetProps & Partial<COverlayProps> & {
-    closeOnClickOutside?: boolean;
-    closeOnContentClick?: boolean;
-    ssr?: boolean;
-    transition?: string;
+type __VLS_WithSlots$8<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };
-type CMenuSlots = {
-    activator?(props: {
-        on: ActivatorListeners;
-        activator: Record<string, any>;
-    }): VNode;
-    default(): VNode;
-};
-type CMenuEvents = {
-    (e: 'outside-click'): void;
-    (e: 'click'): void;
-    (e: 'open'): void;
-    (e: 'close'): void;
-    (e: 'update:modelValue', val: boolean): void;
+
+type DateLocale = {
+    months: string[];
+    monthsAbbr: string[];
+    week: string[];
+};
+
+declare function datePickerValueToString(value: Date | string | null | undefined, format: string, lang: string): string;
+
+type __VLS_Props$5 = CDateInputProps;
+type __VLS_Slots$7 = {
+    prepend?(): any;
+    append?(): any;
+    date?(props: DatePickerDate & {
+        isSelected: boolean;
+        isToday: boolean;
+    }): any;
+    week?(props: {
+        days: DatePickerWeekDay[];
+    }): any;
+    dates?(props: {
+        dates: DatePickerEnrichedDate[];
+        onSelect: (d: DatePickerDate) => void;
+    }): any;
+    'before-header'?(props: DatePickerSlotApi): any;
+    header?(props: DatePickerSlotApi): any;
+    'before-body'?(props: DatePickerSlotApi): any;
+    body?(props: DatePickerSlotApi): any;
+    footer?(props: DatePickerSlotApi): any;
+};
+type CDateInputProps = ValidateProps & PresetProps & {
+    modelValue?: Date | null;
+    label?: string;
+    details?: string;
+    noDetails?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    typeable?: boolean;
+    placeholder?: string;
+    lang?: string;
+    format?: string;
+    mondayFirst?: boolean;
+    disabledDates?: DisabledDates;
+    highlightedDates?: (Date | string)[];
+    minDate?: Date | string;
+    maxDate?: Date | string;
+};
+type __VLS_PublicProps$4 = __VLS_Props$5 & {
+    modelValue?: Date | null;
+};
+declare const __VLS_component$7: vue.DefineComponent<__VLS_PublicProps$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    focus: () => any;
+    blur: () => any;
+    "update:modelValue": (...args: unknown[]) => any;
+}, string, vue.PublicProps, Readonly<__VLS_PublicProps$4> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    onBlur?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$d: __VLS_WithSlots$7<typeof __VLS_component$7, __VLS_Slots$7>;
+
+type __VLS_WithSlots$7<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };
 
-type __VLS_Props$2 = CMenuProps;
-type __VLS_PublicProps$1 = __VLS_Props$2 & {
-    modelValue?: boolean;
+type COverlayProps = {
+    modelValue: boolean;
+    to?: string;
 };
-declare var __VLS_1$1: {
-    on: vue.Raw<{
-        focus?: (() => void) | undefined;
-        click?: (() => void) | undefined;
-        mouseleave?: (() => void) | undefined;
-        mouseenter?: (() => void) | undefined;
-    }>;
-    activator: Record<string, any>;
+type COverlaySlots = {
+    default?(props: {
+        zIndex: number;
+    }): VNode;
 };
-declare var __VLS_11: {};
-type __VLS_Slots$3 = {} & {
-    activator?: (props: typeof __VLS_1$1) => any;
-} & {
-    default?: (props: typeof __VLS_11) => any;
+
+type __VLS_Props$4 = COverlayProps;
+type __VLS_Slots$6 = COverlaySlots;
+type __VLS_PublicProps$3 = __VLS_Props$4 & {
+    modelValue?: boolean;
 };
-declare const __VLS_component$3: vue.DefineComponent<__VLS_PublicProps$1, {
-    open: () => Promise<void>;
-    close: () => void;
-    toggle: () => void | Promise<void>;
-}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+declare const __VLS_component$6: vue.DefineComponent<__VLS_PublicProps$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     "update:modelValue": (value: boolean) => any;
-} & {
-    click: () => any;
-    close: () => any;
-    "update:modelValue": (val: boolean) => any;
-    "outside-click": () => any;
-    open: () => any;
-}, string, vue.PublicProps, Readonly<__VLS_PublicProps$1> & Readonly<{
-    onClick?: (() => any) | undefined;
-    onClose?: (() => any) | undefined;
+}, string, vue.PublicProps, Readonly<__VLS_PublicProps$3> & Readonly<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    "onOutside-click"?: (() => any) | undefined;
-    onOpen?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$a: __VLS_WithSlots$3<typeof __VLS_component$3, __VLS_Slots$3>;
+declare const _default$c: __VLS_WithSlots$6<typeof __VLS_component$6, __VLS_Slots$6>;
 
-type __VLS_WithSlots$3<T, S> = T & {
+type __VLS_WithSlots$6<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-//# sourceMappingURL=CMenu.vue.d.ts.map
-
-type IconMode = 'lib' | 'sprite' | 'component' | 'raw';
-type CIconProps = {
-    name?: string | number;
-    source?: IconMode;
-    component?: Component | null;
-    body?: string;
-    viewBox?: string;
-    size?: string | number;
-    width?: string | number;
-    height?: string | number;
-    tag?: string;
-    spritePrefix?: string;
-    spritePath?: string;
-};
-
-declare const _default$9: vue.DefineComponent<CIconProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<CIconProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-//# sourceMappingURL=CIcon.vue.d.ts.map
+//# sourceMappingURL=COverlay.vue.d.ts.map
 
-type CCheckboxProps<T> = Omit<ValidateProps, 'validateOn'> & {
-    modelValue: T | T[] | boolean;
-    label?: string;
-    size?: number;
+type CDialogProps = COverlayProps & {
+    closeOnClickOutside?: boolean;
 };
-type CCheckboxSlots = {
-    icon(props: {
-        checked: boolean;
-    }): VNode;
+type CDialogSlots = {
     default(): VNode;
 };
-type CCheckboxEvents<T> = {
-    (e: 'update:modelValue', value: T): void;
-};
 
-declare const _default$8: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal$4<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (Omit<ValidateProps, "validateOn"> & {
-        modelValue: boolean | T | T[];
-        label?: string;
-        size?: number;
-    } & {
-        modelValue?: T;
-    }) & Partial<{}>> & vue.PublicProps;
-    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: CCheckboxSlots;
-    emit: (evt: "update:modelValue", value: T | undefined) => void;
-}>) => vue.VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+type __VLS_Props$3 = CDialogProps;
+type __VLS_Slots$5 = CDialogSlots;
+type __VLS_PublicProps$2 = __VLS_Props$3 & {
+    modelValue?: boolean;
 };
+declare const __VLS_component$5: vue.DefineComponent<__VLS_PublicProps$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, vue.PublicProps, Readonly<__VLS_PublicProps$2> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$b: __VLS_WithSlots$5<typeof __VLS_component$5, __VLS_Slots$5>;
 
-type __VLS_PrettifyLocal$4<T> = {
-    [K in keyof T]: T[K];
-} & {};
-//# sourceMappingURL=CCheckbox.vue.d.ts.map
-
-declare const _default$7: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal$3<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
-        label?: string;
-    } & {
-        modelValue?: T;
-    }) & Partial<{}>> & vue.PublicProps;
-    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {
-        default?: (props: {}) => any;
+type __VLS_WithSlots$5<T, S> = T & {
+    new (): {
+        $slots: S;
     };
-    emit: (evt: "update:modelValue", value: T | undefined) => void;
-}>) => vue.VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
 };
+//# sourceMappingURL=CDialog.vue.d.ts.map
 
-type __VLS_PrettifyLocal$3<T> = {
-    [K in keyof T]: T[K];
-} & {};
-//# sourceMappingURL=CRadio.vue.d.ts.map
+declare const _default$a: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=CDialogsStack.vue.d.ts.map
 
-declare var __VLS_6: {
-    activator: Record<string, any>;
-    on: vue.Raw<{
-        focus?: (() => void) | undefined;
-        click?: (() => void) | undefined;
-        mouseleave?: (() => void) | undefined;
-        mouseenter?: (() => void) | undefined;
-    }>;
+type CFieldProps = {
+    tag?: 'input' | 'textarea';
+    label?: string;
+    filled?: boolean;
+    preset?: string;
+    focused?: boolean;
+    clearable?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    noInput?: boolean;
+    modelValue?: string | number | undefined | null;
 };
-declare var __VLS_8: {};
-type __VLS_Slots$2 = {} & {
-    activator?: (props: typeof __VLS_6) => any;
+type CFieldSlots = {
+    prepend?(): VNode;
+    append?(): VNode;
+    before?(): VNode | VNode[];
+    after?(): VNode | VNode[];
+    clear?(): VNode;
+};
+
+type __VLS_Props$2 = CFieldProps;
+type __VLS_PublicProps$1 = __VLS_Props$2 & {
+    modelValue?: string | number | undefined | null;
+};
+declare var __VLS_1$3: {};
+declare var __VLS_7: {};
+declare var __VLS_19: {};
+declare var __VLS_25: {};
+declare var __VLS_31: {};
+type __VLS_Slots$4 = {} & {
+    prepend?: (props: typeof __VLS_1$3) => any;
 } & {
-    default?: (props: typeof __VLS_8) => any;
+    before?: (props: typeof __VLS_7) => any;
+} & {
+    after?: (props: typeof __VLS_19) => any;
+} & {
+    clear?: (props: typeof __VLS_25) => any;
+} & {
+    append?: (props: typeof __VLS_31) => any;
 };
-declare const __VLS_component$2: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-declare const _default$6: __VLS_WithSlots$2<typeof __VLS_component$2, __VLS_Slots$2>;
+declare const __VLS_component$4: vue.DefineComponent<__VLS_PublicProps$1, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | null | undefined) => any;
+} & {
+    clear: () => any;
+}, string, vue.PublicProps, Readonly<__VLS_PublicProps$1> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$9: __VLS_WithSlots$4<typeof __VLS_component$4, __VLS_Slots$4>;
 
-type __VLS_WithSlots$2<T, S> = T & {
+type __VLS_WithSlots$4<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-//# sourceMappingURL=CTooltip.vue.d.ts.map
+//# sourceMappingURL=CField.vue.d.ts.map
 
-type CLabelProps = {
-    tag?: string;
+type ValidatorFn = () => boolean | Promise<boolean>;
+type ResetFn = () => void;
+interface FormAPI {
+    add(fn: ValidatorFn): void;
+    remove(fn: ValidatorFn): void;
+    addReset(fn: ResetFn): void;
+    removeReset(fn: ResetFn): void;
+}
+type CFormProps = {
+    label?: string;
 };
-
-declare const CLabel: FunctionalComponent<CLabelProps>;
-
-type __VLS_Props$1 = {
-    fixed?: boolean;
+type CFormEmits = {
+    submit: [event: Event];
 };
-declare var __VLS_1: {};
-type __VLS_Slots$1 = {} & {
-    default?: (props: typeof __VLS_1) => any;
+type CFormSlots = {
+    default(props: {
+        validate: ValidatorFn;
+        reset: () => void;
+    }): VNode;
 };
-declare const __VLS_component$1: vue.DefineComponent<__VLS_Props$1, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$1> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$5: __VLS_WithSlots$1<typeof __VLS_component$1, __VLS_Slots$1>;
 
-type __VLS_WithSlots$1<T, S> = T & {
+type __VLS_Slots$3 = CFormSlots;
+declare function validate(): Promise<boolean>;
+declare function reset(): void;
+declare const __VLS_component$3: vue.DefineComponent<CFormProps, {
+    validate: typeof validate;
+    reset: typeof reset;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    submit: (event: Event) => any;
+}, string, vue.PublicProps, Readonly<CFormProps> & Readonly<{
+    onSubmit?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$8: __VLS_WithSlots$3<typeof __VLS_component$3, __VLS_Slots$3>;
+
+type __VLS_WithSlots$3<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-//# sourceMappingURL=CToolbar.vue.d.ts.map
+//# sourceMappingURL=CForm.vue.d.ts.map
+
+declare const CCol: vue.DefineComponent<vue.ExtractPropTypes<{
+    order: {
+        type: PropType<string | number>;
+        default: null;
+    };
+    cols: {
+        type: PropType<string | number>;
+        default: null;
+    };
+    offset: {
+        type: PropType<string | number>;
+        default: null;
+    };
+}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    order: {
+        type: PropType<string | number>;
+        default: null;
+    };
+    cols: {
+        type: PropType<string | number>;
+        default: null;
+    };
+    offset: {
+        type: PropType<string | number>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    order: string | number;
+    cols: string | number;
+    offset: string | number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const justifyValues: readonly ["start", "center", "end", "space-between", "space-around"];
+declare const alignValues: readonly ["start", "center", "end", "baseline", "stretch"];
+declare const alignContentValues: readonly ["start", "center", "end", "space-between", "space-around", "stretch"];
+type JustifyValue = (typeof justifyValues)[number];
+type AlignValue = (typeof alignValues)[number];
+type AlignContentValue = (typeof alignContentValues)[number];
+declare const CRow: vue.DefineComponent<vue.ExtractPropTypes<{
+    align: {
+        type: PropType<AlignValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    alignContent: {
+        type: PropType<AlignContentValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    justify: {
+        type: PropType<JustifyValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    noGutter: BooleanConstructor;
+}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    align: {
+        type: PropType<AlignValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    alignContent: {
+        type: PropType<AlignContentValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    justify: {
+        type: PropType<JustifyValue>;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    noGutter: BooleanConstructor;
+}>> & Readonly<{}>, {
+    align: "start" | "center" | "end" | "baseline" | "stretch";
+    noGutter: boolean;
+    alignContent: "start" | "center" | "end" | "space-between" | "space-around" | "stretch";
+    justify: "start" | "center" | "end" | "space-between" | "space-around";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const CSpacer: vue.FunctionalComponent<{}, {}, any, {}>;
+
+type CIconProps = {
+    name?: string | number;
+    source?: IconMode;
+    component?: Component | null;
+    body?: string;
+    viewBox?: string;
+    size?: string | number;
+    width?: string | number;
+    height?: string | number;
+    tag?: string;
+    spritePrefix?: string;
+    spritePath?: string;
+};
+
+declare const _default$7: vue.DefineComponent<CIconProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<CIconProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+//# sourceMappingURL=CIcon.vue.d.ts.map
+
+type CLabelProps = {
+    tag?: string;
+};
 
-declare const CToolbarLogo: vue.FunctionalComponent<{}, {}, any, {}>;
-declare const CToolbarItems: vue.FunctionalComponent<{}, {}, any, {}>;
+declare const CLabel: FunctionalComponent<CLabelProps>;
 
+type CListRole = 'listbox' | 'menu' | undefined;
 type CListProps<T> = {
     modelValue?: T | T[] | null;
     multiple?: boolean;
     mandatory?: boolean;
     readonly?: boolean;
+    selectable?: boolean;
+    role?: CListRole;
 };
 type CListSlots<T> = {
     default?(props: {
@@ -557,14 +840,34 @@ type CListSlots<T> = {
         isActive(item: T): boolean;
     }): VNode | VNode[];
 };
+type ListItemControls = {
+    focus(): void;
+    blur(): void;
+};
+type ListAPI<T = any> = {
+    role: ComputedRef<CListRole>;
+    listId: string;
+    register(controls: ListItemControls): number;
+    unregister(controls: ListItemControls): void;
+    select(value: T): void;
+    unselect(value: T): void;
+    isActive(value: T): boolean;
+    setDescendant(id: string | undefined): void;
+};
 
-declare const _default$4: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal$2<Pick<Partial<{}> & Omit<{
+declare const _default$6: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal$3<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: T | T[] | null) => any) | undefined;
     } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (CListProps<T> & {
         modelValue?: T | T[] | null;
     }) & Partial<{}>> & vue.PublicProps;
-    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
+    expose(exposed: vue.ShallowUnwrapRef<{
+        focus: () => Promise<void>;
+        listId: string;
+        activeDescendant: vue.ShallowRef<string | undefined, string | undefined>;
+        navigateDown: () => void;
+        navigateUp: () => void;
+    }>): void;
     attrs: any;
     slots: CListSlots<T>;
     emit: (evt: "update:modelValue", value: T | T[] | null) => void;
@@ -572,13 +875,13 @@ declare const _default$4: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setu
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 
-type __VLS_PrettifyLocal$2<T> = {
+type __VLS_PrettifyLocal$3<T> = {
     [K in keyof T]: T[K];
 } & {};
 //# sourceMappingURL=CList.vue.d.ts.map
 
-declare const _default$3: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal$1<Pick<Partial<{}> & Omit<{} & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, never> & {
+declare const _default$5: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal$2<Pick<Partial<{}> & Omit<{} & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, never> & {
         value?: T;
     } & Partial<{}>> & vue.PublicProps;
     expose(exposed: vue.ShallowUnwrapRef<{}>): void;
@@ -591,7 +894,7 @@ declare const _default$3: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VL
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 
-type __VLS_PrettifyLocal$1<T> = {
+type __VLS_PrettifyLocal$2<T> = {
     [K in keyof T]: T[K];
 } & {};
 //# sourceMappingURL=CListItem.vue.d.ts.map
@@ -599,138 +902,112 @@ type __VLS_PrettifyLocal$1<T> = {
 declare const CListItemIcon: vue.FunctionalComponent<{}, {}, any, {}>;
 declare const CListItemTitle: vue.FunctionalComponent<{}, {}, any, {}>;
 
-type CItemsProps = {
-    modelValue: any;
-    multiple?: boolean;
-    mandatory?: boolean;
-    options?: {
-        extKey?: string;
-        noItemsMessage?: string;
-        menuClass?: string;
-    };
-    items: any[];
-};
-type CItemsSlots = {
-    'no-items-message'?: () => any;
-};
-declare const CItems: vue.DefineComponent<CItemsProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<CItemsProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-
 declare const CMain: vue.FunctionalComponent<{}, {}, any, {}>;
 
-declare const CCard: vue.FunctionalComponent<{}, {}, any, {}>;
-declare const CCardHeader: vue.FunctionalComponent<{}, {}, any, {}>;
-declare const CCardBody: vue.FunctionalComponent<{}, {}, any, {}>;
-declare const CCardFooter: vue.FunctionalComponent<{}, {}, any, {}>;
-
-declare const justifyValues: readonly ["start", "center", "end", "space-between", "space-around"];
-declare const alignValues: readonly ["start", "center", "end", "baseline", "stretch"];
-declare const alignContentValues: readonly ["start", "center", "end", "space-between", "space-around", "stretch"];
-type JustifyValue = (typeof justifyValues)[number];
-type AlignValue = (typeof alignValues)[number];
-type AlignContentValue = (typeof alignContentValues)[number];
-declare const CRow: vue.DefineComponent<vue.ExtractPropTypes<{
-    align: {
-        type: PropType<AlignValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    alignContent: {
-        type: PropType<AlignContentValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    justify: {
-        type: PropType<JustifyValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    noGutter: BooleanConstructor;
-}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    align: {
-        type: PropType<AlignValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    alignContent: {
-        type: PropType<AlignContentValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    justify: {
-        type: PropType<JustifyValue>;
-        default: null;
-        validator: (value: string) => boolean;
-    };
-    noGutter: BooleanConstructor;
-}>> & Readonly<{}>, {
-    noGutter: boolean;
-    align: "start" | "center" | "end" | "baseline" | "stretch";
-    alignContent: "start" | "center" | "end" | "space-between" | "space-around" | "stretch";
-    justify: "start" | "center" | "end" | "space-between" | "space-around";
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-declare const CCol: vue.DefineComponent<vue.ExtractPropTypes<{
-    order: {
-        type: PropType<string | number>;
-        default: null;
-    };
-    cols: {
-        type: PropType<string | number>;
-        default: null;
-    };
-    offset: {
-        type: PropType<string | number>;
-        default: null;
-    };
-}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    order: {
-        type: PropType<string | number>;
-        default: null;
-    };
-    cols: {
-        type: PropType<string | number>;
-        default: null;
-    };
-    offset: {
-        type: PropType<string | number>;
-        default: null;
-    };
-}>> & Readonly<{}>, {
-    order: string | number;
-    cols: string | number;
-    offset: string | number;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-declare const CSpacer: vue.FunctionalComponent<{}, {}, any, {}>;
-
-type CDialogProps = COverlayProps & {
+type CMenuProps = ActivatorProps & DimensionsProps & AutoPositionProps & DelayProps & Partial<COverlayProps> & {
     closeOnClickOutside?: boolean;
+    closeOnContentClick?: boolean;
+    ssr?: boolean;
+    transition?: string;
 };
-type CDialogSlots = {
+type CMenuSlots = {
+    activator?(props: {
+        on: ActivatorListeners;
+        activator: Record<string, any>;
+    }): VNode;
     default(): VNode;
 };
+type CMenuEvents = {
+    (e: 'outside-click'): void;
+    (e: 'click'): void;
+    (e: 'open'): void;
+    (e: 'close'): void;
+    (e: 'update:modelValue', val: boolean): void;
+};
 
-type __VLS_Slots = CDialogSlots;
-type __VLS_Props = CDialogProps;
-type __VLS_PublicProps = __VLS_Props & {
+type __VLS_Props$1 = CMenuProps;
+type __VLS_PublicProps = __VLS_Props$1 & {
     modelValue?: boolean;
 };
-declare const __VLS_component: vue.DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+declare var __VLS_1$2: {
+    on: vue.Raw<{
+        focus?: (() => void) | undefined;
+        click?: (() => void) | undefined;
+        mouseleave?: (() => void) | undefined;
+        mouseenter?: (() => void) | undefined;
+    }>;
+    activator: Record<string, any>;
+};
+declare var __VLS_11: {};
+type __VLS_Slots$2 = {} & {
+    activator?: (props: typeof __VLS_1$2) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_component$2: vue.DefineComponent<__VLS_PublicProps, {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     "update:modelValue": (value: boolean) => any;
+} & {
+    open: () => any;
+    close: () => any;
+    click: () => any;
+    "update:modelValue": (val: boolean) => any;
+    "outside-click": () => any;
 }, string, vue.PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onOpen?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onClick?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onOutside-click"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$2: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const _default$4: __VLS_WithSlots$2<typeof __VLS_component$2, __VLS_Slots$2>;
 
-type __VLS_WithSlots<T, S> = T & {
+type __VLS_WithSlots$2<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-//# sourceMappingURL=CDialog.vue.d.ts.map
+//# sourceMappingURL=CMenu.vue.d.ts.map
 
-declare const _default$1: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-//# sourceMappingURL=CDialogsStack.vue.d.ts.map
+declare const _default$3: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal$1<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        label?: string;
+    } & {
+        modelValue?: T;
+    }) & Partial<{}>> & vue.PublicProps;
+    expose(exposed: vue.ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | undefined) => void;
+}>) => vue.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
+type __VLS_PrettifyLocal$1<T> = {
+    [K in keyof T]: T[K];
+} & {};
+//# sourceMappingURL=CRadio.vue.d.ts.map
+
+declare var __VLS_1$1: {};
+type __VLS_Slots$1 = {} & {
+    default?: (props: typeof __VLS_1$1) => any;
+};
+declare const __VLS_component$1: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const _default$2: __VLS_WithSlots$1<typeof __VLS_component$1, __VLS_Slots$1>;
+
+type __VLS_WithSlots$1<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=CRadioGroup.vue.d.ts.map
 
 type CScrimProps = {
     blur?: boolean;
@@ -738,34 +1015,45 @@ type CScrimProps = {
 };
 declare const CScrim: (props: CScrimProps, ctx: any) => VNode;
 
-interface CSelectControlProps<T = any> {
-    modelValue: T | T[] | boolean;
-    value?: T;
-    multiple?: boolean;
-    focused?: boolean;
-    disabled?: boolean;
-    readonly?: boolean;
-    name?: string;
-}
-interface CSelectControlSlots {
-    default(props: {
-        checked: boolean;
-        disabled: boolean;
-        readonly: boolean;
-        toggle: () => void;
+type CSelectProps<T> = SelectableProps<T> & IterableItemsProps<T> & {
+    options?: {
+        extKey?: string;
+        noItemsMessage?: string;
+    };
+};
+type CSelectSlots<T> = {
+    menu(props: {
+        items: NormalizedItem<T>[];
+        onSelect(val: T): void;
+    }): void;
+    field: CInputSlots['field'];
+    prepend(): VNode;
+    append(): VNode;
+    selects(props: {
+        items: T[];
+    }): VNode[];
+    details(props: {
+        errorMessage?: string;
+        details?: string;
     }): VNode;
-}
+    ['no-items-message'](): string;
+};
 
-declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const _default$1: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:modelValue"?: ((value: boolean | T | T[]) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (CSelectControlProps<any> & {
-        modelValue?: T | T[] | boolean;
+        readonly "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>, "onUpdate:modelValue"> & (SelectableProps<T> & IterableItemsProps<T> & {
+        options?: {
+            extKey?: string;
+            noItemsMessage?: string;
+        };
+    } & {
+        modelValue?: T | T[];
     }) & Partial<{}>> & vue.PublicProps;
     expose(exposed: vue.ShallowUnwrapRef<{}>): void;
     attrs: any;
-    slots: CSelectControlSlots;
-    emit: (evt: "update:modelValue", value: boolean | T | T[]) => void;
+    slots: CSelectSlots<T>;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
 }>) => vue.VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
@@ -773,7 +1061,56 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
 type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};
-//# sourceMappingURL=CSelectControl.vue.d.ts.map
+//# sourceMappingURL=CSelect.vue.d.ts.map
+
+type CTextFieldProps = Omit<CInputProps, 'modelValue' | 'role'>;
+type CTextFieldSlots = {
+    prepend(): VNode;
+    append(): VNode;
+    details(props: {
+        errorMessage?: string;
+        details?: string;
+        hasError: boolean;
+    }): VNode;
+};
+type CTextFieldEmits<T = any> = {
+    (e: 'update:modelValue', val: T): void;
+};
+
+type CTextFieldComponent = new <T = any>() => {
+    $props: CTextFieldProps & {
+        modelValue?: T;
+    };
+    $slots: CTextFieldSlots;
+    $emits: CTextFieldEmits<T>;
+};
+declare const CTextField: CTextFieldComponent;
+
+type __VLS_Props = {
+    fixed?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=CToolbar.vue.d.ts.map
+
+declare const CToolbarLogo: vue.FunctionalComponent<{}, {}, any, {}>;
+declare const CToolbarItems: vue.FunctionalComponent<{}, {}, any, {}>;
+
+type CTooltipComponent = new () => {
+    $props: CMenuProps;
+    $slots: CMenuSlots;
+};
+declare const CTooltip: CTooltipComponent;
 
-export { _default$j as CApp, _default$d as CAutocomplete, _default$i as CBtn, CCard, CCardBody, CCardFooter, CCardHeader, _default$8 as CCheckbox, CCol, _default$2 as CDialog, _default$1 as CDialogsStack, _default$e as CField, _default$h as CForm, _default$9 as CIcon, _default$g as CInput, CItems, CLabel, _default$4 as CList, _default$3 as CListItem, CListItemIcon, CListItemTitle, CMain, _default$a as CMenu, _default$b as COverlay, _default$7 as CRadio, CRow, CScrim, _default$c as CSelect, _default as CSelectControl, CSpacer, _default$f as CTextField, _default$5 as CToolbar, CToolbarItems, CToolbarLogo, _default$6 as CTooltip };
-export type { ApplicationApi, CAutocompleteProps, CAutocompleteSlots, CCheckboxEvents, CCheckboxProps, CCheckboxSlots, CDialogProps, CDialogSlots, CInputProps, CInputSlots, CItemsProps, CItemsSlots, CListProps, CListSlots, CMenuEvents, CMenuProps, CMenuSlots, COverlayProps, COverlaySlots, CScrimProps, CSelectControlProps, CSelectControlSlots, CSelectProps, CSelectSlots, FormApi, FormSlots, ValidatorFn };
+export { _default$l as CApp, _default$i as CAutocomplete, _default$k as CBtn, CCard, CCardBody, CCardFooter, CCardHeader, _default$g as CCheckbox, _default$f as CChip, CCol, _default$d as CDateInput, _default$e as CDatePicker, _default$b as CDialog, _default$a as CDialogsStack, _default$9 as CField, _default$8 as CForm, _default$7 as CIcon, _default$j as CInput, CLabel, _default$6 as CList, _default$5 as CListItem, CListItemIcon, CListItemTitle, CMain, _default$4 as CMenu, _default$c as COverlay, _default$3 as CRadio, _default$2 as CRadioGroup, CRow, CScrim, _default$1 as CSelect, _default$h as CSelectControl, CSpacer, CTextField, _default as CToolbar, CToolbarItems, CToolbarLogo, CTooltip, datePickerValueToString };
+export type { ApplicationApi, CAppSlots, CAutocompleteProps, CAutocompletePublicProps, CAutocompleteSlots, CBtnProps, CCheckboxEvents, CCheckboxModel, CCheckboxProps, CCheckboxPublicProps, CCheckboxSlots, CDateInputProps, CDatePickerProps, CDialogProps, CDialogSlots, CFieldProps, CFieldSlots, CFormEmits, CFormProps, CFormSlots, CInputDetailsSlotProps, CInputEmits, CInputFieldSlotProps, CInputProps, CInputRole, CInputSlots, CLabelProps, CListProps, CListRole, CListSlots, CMenuEvents, CMenuProps, CMenuSlots, COverlayProps, COverlaySlots, CScrimProps, CSelectControlProps, CSelectControlSlots, CSelectProps, CSelectSlots, CTextFieldProps, CTextFieldSlots, DateLocale, DatePickerDate, DatePickerEnrichedDate, DatePickerEnrichedMonth, DatePickerEnrichedYear, DatePickerSlotApi, DatePickerWeekDay, DisabledDates, FormAPI, InputState, ListAPI, ListItemControls, ResetFn, ValidatorFn };