1) All these methods are in the @dxtmisha/constructor library.
2) Everything that is exported can be used.
3) Use what is in this library if it exists; do not use other libraries if there is an analogue here. Do not create new ones if an analogue already exists here.

The following is the content of "exports" from package.json:
{
  ".": {
    "types": "./dist/library.d.ts",
    "default": "./dist/library.js"
  },
  "./Accordion": {
    "types": "./dist/constructors/Accordion/index.d.ts",
    "default": "./dist/accordion.js"
  },
  "./ActionSheet": {
    "types": "./dist/constructors/ActionSheet/index.d.ts",
    "default": "./dist/actionSheet.js"
  },
  "./Actions": {
    "types": "./dist/constructors/Actions/index.d.ts",
    "default": "./dist/actions.js"
  },
  "./Anchor": {
    "types": "./dist/constructors/Anchor/index.d.ts",
    "default": "./dist/anchor.js"
  },
  "./Area": {
    "types": "./dist/constructors/Area/index.d.ts",
    "default": "./dist/area.js"
  },
  "./Arrow": {
    "types": "./dist/constructors/Arrow/index.d.ts",
    "default": "./dist/arrow.js"
  },
  "./Badge": {
    "types": "./dist/constructors/Badge/index.d.ts",
    "default": "./dist/badge.js"
  },
  "./Bars": {
    "types": "./dist/constructors/Bars/index.d.ts",
    "default": "./dist/bars.js"
  },
  "./Block": {
    "types": "./dist/constructors/Block/index.d.ts",
    "default": "./dist/block.js"
  },
  "./Button": {
    "types": "./dist/constructors/Button/index.d.ts",
    "default": "./dist/button.js"
  },
  "./Cell": {
    "types": "./dist/constructors/Cell/index.d.ts",
    "default": "./dist/cell.js"
  },
  "./Checkbox": {
    "types": "./dist/constructors/Checkbox/index.d.ts",
    "default": "./dist/checkbox.js"
  },
  "./Chip": {
    "types": "./dist/constructors/Chip/index.d.ts",
    "default": "./dist/chip.js"
  },
  "./ChipGroup": {
    "types": "./dist/constructors/ChipGroup/index.d.ts",
    "default": "./dist/chipGroup.js"
  },
  "./Dialog": {
    "types": "./dist/constructors/Dialog/index.d.ts",
    "default": "./dist/dialog.js"
  },
  "./Dummy": {
    "types": "./dist/constructors/Dummy/index.d.ts",
    "default": "./dist/dummy.js"
  },
  "./Field": {
    "types": "./dist/constructors/Field/index.d.ts",
    "default": "./dist/field.js"
  },
  "./FieldCounter": {
    "types": "./dist/constructors/FieldCounter/index.d.ts",
    "default": "./dist/fieldCounter.js"
  },
  "./FieldLabel": {
    "types": "./dist/constructors/FieldLabel/index.d.ts",
    "default": "./dist/fieldLabel.js"
  },
  "./FieldMessage": {
    "types": "./dist/constructors/FieldMessage/index.d.ts",
    "default": "./dist/fieldMessage.js"
  },
  "./Grid": {
    "types": "./dist/constructors/Grid/index.d.ts",
    "default": "./dist/grid.js"
  },
  "./GridItem": {
    "types": "./dist/constructors/GridItem/index.d.ts",
    "default": "./dist/gridItem.js"
  },
  "./Group": {
    "types": "./dist/constructors/Group/index.d.ts",
    "default": "./dist/group.js"
  },
  "./Header": {
    "types": "./dist/constructors/Header/index.d.ts",
    "default": "./dist/header.js"
  },
  "./HorizontalScroll": {
    "types": "./dist/constructors/HorizontalScroll/index.d.ts",
    "default": "./dist/horizontalScroll.js"
  },
  "./Icon": {
    "types": "./dist/constructors/Icon/index.d.ts",
    "default": "./dist/icon.js"
  },
  "./Image": {
    "types": "./dist/constructors/Image/index.d.ts",
    "default": "./dist/image.js"
  },
  "./Input": {
    "types": "./dist/constructors/Input/index.d.ts",
    "default": "./dist/input.js"
  },
  "./List": {
    "types": "./dist/constructors/List/index.d.ts",
    "default": "./dist/list.js"
  },
  "./ListGroup": {
    "types": "./dist/constructors/ListGroup/index.d.ts",
    "default": "./dist/listGroup.js"
  },
  "./ListItem": {
    "types": "./dist/constructors/ListItem/index.d.ts",
    "default": "./dist/listItem.js"
  },
  "./ListMenu": {
    "types": "./dist/constructors/ListMenu/index.d.ts",
    "default": "./dist/listMenu.js"
  },
  "./Mask": {
    "types": "./dist/constructors/Mask/index.d.ts",
    "default": "./dist/mask.js"
  },
  "./Menu": {
    "types": "./dist/constructors/Menu/index.d.ts",
    "default": "./dist/menu.js"
  },
  "./Modal": {
    "types": "./dist/constructors/Modal/index.d.ts",
    "default": "./dist/modal.js"
  },
  "./MotionAxis": {
    "types": "./dist/constructors/MotionAxis/index.d.ts",
    "default": "./dist/motionAxis.js"
  },
  "./MotionTransform": {
    "types": "./dist/constructors/MotionTransform/index.d.ts",
    "default": "./dist/motionTransform.js"
  },
  "./Page": {
    "types": "./dist/constructors/Page/index.d.ts",
    "default": "./dist/page.js"
  },
  "./Progress": {
    "types": "./dist/constructors/Progress/index.d.ts",
    "default": "./dist/progress.js"
  },
  "./Ripple": {
    "types": "./dist/constructors/Ripple/index.d.ts",
    "default": "./dist/ripple.js"
  },
  "./Scrollbar": {
    "types": "./dist/constructors/Scrollbar/index.d.ts",
    "default": "./dist/scrollbar.js"
  },
  "./Section": {
    "types": "./dist/constructors/Section/index.d.ts",
    "default": "./dist/section.js"
  },
  "./Select": {
    "types": "./dist/constructors/Select/index.d.ts",
    "default": "./dist/select.js"
  },
  "./SelectValue": {
    "types": "./dist/constructors/SelectValue/index.d.ts",
    "default": "./dist/selectValue.js"
  },
  "./Skeleton": {
    "types": "./dist/constructors/Skeleton/index.d.ts",
    "default": "./dist/skeleton.js"
  },
  "./Snackbar": {
    "types": "./dist/constructors/Snackbar/index.d.ts",
    "default": "./dist/snackbar.js"
  },
  "./SnackbarItem": {
    "types": "./dist/constructors/SnackbarItem/index.d.ts",
    "default": "./dist/snackbarItem.js"
  },
  "./TabItem": {
    "types": "./dist/constructors/TabItem/index.d.ts",
    "default": "./dist/tabItem.js"
  },
  "./Tabs": {
    "types": "./dist/constructors/Tabs/index.d.ts",
    "default": "./dist/tabs.js"
  },
  "./TabsNavigation": {
    "types": "./dist/constructors/TabsNavigation/index.d.ts",
    "default": "./dist/tabsNavigation.js"
  },
  "./Textarea": {
    "types": "./dist/constructors/Textarea/index.d.ts",
    "default": "./dist/textarea.js"
  },
  "./TextareaAutosize": {
    "types": "./dist/constructors/TextareaAutosize/index.d.ts",
    "default": "./dist/textareaAutosize.js"
  },
  "./Tooltip": {
    "types": "./dist/constructors/Tooltip/index.d.ts",
    "default": "./dist/tooltip.js"
  },
  "./Window": {
    "types": "./dist/constructors/Window/index.d.ts",
    "default": "./dist/window.js"
  },
  "./ai-types": "./ai-types.txt",
  "./plugin": {
    "types": "./dist/library/plugin.d.ts",
    "default": "./dist/plugin.js"
  },
  "./style.scss": "./src/library/style.scss",
  "./Container": {
    "types": "./dist/constructors/Container/index.d.ts",
    "default": "./dist/container.js"
  },
  "./ClientOnly": {
    "types": "./dist/constructors/ClientOnly/index.d.ts",
    "default": "./dist/clientOnly.js"
  },
  "./PageArea": {
    "types": "./dist/constructors/PageArea/index.d.ts",
    "default": "./dist/pageArea.js"
  }
}

// File: classes/AreaInclude.d.ts
/**
 * Manages the area value.
 */
export declare class AreaInclude {
    /**
     * Constructor.
     * @param props input data
     */
    constructor(props: AreaProps);
}

// File: classes/AriaStaticInclude.d.ts
/**
 * Returns static ARIA attributes.
 */
export declare class AriaStaticInclude {
    /**
     * Get role by props.
     * @param role ARIA role type
     */
    static role(role?: RoleType): AriaList;
    /**
     * Get ARIA atomic attribute.
     * @param isAtomic is atomic
     */
    static atomic(isAtomic?: boolean): AriaList;
    /**
     * Get ARIA checked attribute.
     * @param isChecked is checked
     */
    static checked(isChecked?: boolean): AriaList;
    /**
     * Get ARIA controls attribute.
     * @param controls ARIA controls attribute
     */
    static controls(controls?: string): AriaList;
    /**
     * Get ARIA current attribute.
     * @param value ARIA current attribute
     */
    static current(value?: AriaList['aria-current']): AriaList;
    /**
     * Get ARIA busy attribute.
     * @param isBusy is busy
     */
    static busy(isBusy?: boolean): AriaList;
    /**
     * Get ARIA describedby attribute.
     * @param id Element ID
     */
    static describedby(id?: string): AriaList;
    /**
     * Get ARIA disabled attribute.
     * @param isDisabled is disabled
     */
    static disabled(isDisabled?: boolean): AriaList;
    /**
     * Get ARIA expanded attribute.
     * @param isExpanded is expanded
     */
    static expanded(isExpanded?: boolean): AriaList;
    /**
     * Get ARIA haspopup attribute.
     * @param haspopup ARIA haspopup attribute
     */
    static haspopup(haspopup?: AriaList['aria-haspopup']): AriaList;
    /**
     * Get ARIA label.
     * @param label ARIA label
     */
    static label(label?: string): AriaList;
    /**
     * Get ARIA labelledby attribute.
     * @param id Element ID
     */
    static labelledby(id?: string): AriaList;
    /**
     * Get ARIA invalid attribute.
     * @param isInvalid is invalid
     */
    static invalid(isInvalid?: boolean): AriaList;
    /**
     * Get control role.
     * @param id Element ID
     * @param controls ARIA controls
     * @param haspopup ARIA haspopup
     * @param expanded ARIA expanded
     */
    static control(id?: string, controls?: string, haspopup?: AriaList['aria-haspopup'], expanded?: boolean): AriaList;
    /**
     * Get ARIA hidden attribute.
     * @param isHidden is hidden
     */
    static hidden(isHidden?: boolean): AriaList;
    /**
     * Get ARIA live attribute.
     * @param live ARIA live attribute
     */
    static live(live?: AriaList['aria-live']): AriaList;
    /**
     * Get ARIA modal attribute.
     * @param isModal is modal
     */
    static ariaModal(isModal?: boolean): AriaList;
    /**
     * Get modal role.
     * @param isModal is modal
     * @param ariaLabelledby ARIA labelledby
     * @param ariaDescribedby ARIA describedby
     */
    static modal(isModal?: boolean, ariaLabelledby?: string, ariaDescribedby?: string): AriaList;
    /**
     * Get ARIA multiselectable attribute.
     * @param isMultiselectable is multiselectable
     */
    static multiselectable(isMultiselectable?: boolean): AriaList;
    /**
     * Get ARIA selected attribute.
     * @param isSelected is selected
     */
    static selected(isSelected?: boolean): AriaList;
    /**
     * Returns ARIA value now, min and max.
     * @param value Current value
     * @param min Minimum value
     * @param max Maximum value
     */
    static valueMinMax(value?: string | number, min?: string | number, max?: string | number): AriaList;
    /**
     * Returns 'true' or 'false' from boolean.
     * @param value boolean value
     */
    static isTrueOrFalse(value?: boolean): AriaTrueOrFalse | undefined;
}

// File: classes/CaptionInclude.d.ts
/**
 * Manages caption text.
 */
export declare class CaptionInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param slots slot object
     * @param skeleton loading state skeleton
     */
    constructor(props: Readonly<CaptionProps>, className: string, slots?: CaptionSlots | undefined, skeleton?: SkeletonInclude | undefined);
    /** Returns true if caption is filled. */
    readonly is: ComputedRef<boolean>;
    /** Returns caption element bindings. */
    readonly binds: ComputedRef<{
        'aria-activedescendant'?: string;
        'aria-atomic'?: AriaTrueOrFalse;
        'aria-autocomplete'?: "none" | "inline" | "list" | "both";
        'aria-busy'?: AriaTrueOrFalse;
        'aria-checked'?: AriaTrueOrFalse | "mixed";
        'aria-colcount'?: number;
        'aria-colindex'?: number;
        'aria-colspan'?: number;
        'aria-controls'?: string;
        'aria-current'?: AriaTrueOrFalse | "page" | "step" | "location" | "date" | "time";
        'aria-describedby'?: string;
        'aria-details'?: string;
        'aria-disabled'?: AriaTrueOrFalse;
        'aria-errormessage'?: string;
        'aria-expanded'?: AriaTrueOrFalse;
        'aria-flowto'?: string;
        'aria-grabbed'?: AriaTrueOrFalse;
        'aria-haspopup'?: AriaTrueOrFalse | "dialog" | "menu" | "listbox" | "tree" | "grid";
        'aria-hidden'?: AriaTrueOrFalse;
        'aria-invalid'?: AriaTrueOrFalse | "grammar" | "spelling";
        'aria-keyshortcuts'?: string;
        'aria-label'?: string;
        'aria-labelledby'?: string;
        'aria-level'?: number;
        'aria-live'?: "off" | "polite" | "assertive";
        'aria-modal'?: AriaTrueOrFalse;
        'aria-multiline'?: AriaTrueOrFalse;
        'aria-multiselectable'?: AriaTrueOrFalse;
        'aria-orientation'?: "horizontal" | "vertical" | "undefined";
        'aria-owns'?: string;
        'aria-placeholder'?: string;
        'aria-posinset'?: number;
        'aria-pressed'?: AriaTrueOrFalse | "mixed";
        'aria-readonly'?: AriaTrueOrFalse;
        'aria-relevant'?: "additions" | "removals" | "text" | "all" | string;
        'aria-required'?: AriaTrueOrFalse;
        'aria-roledescription'?: string;
        'aria-rowcount'?: number;
        'aria-rowindex'?: number;
        'aria-rowspan'?: number;
        'aria-selected'?: AriaTrueOrFalse;
        'aria-setsize'?: number;
        'aria-sort'?: "none" | "ascending" | "descending" | "other";
        'aria-valuemax'?: string | number;
        'aria-valuemin'?: string | number;
        'aria-valuenow'?: string | number;
        'aria-valuetext'?: string;
        id?: string;
        role?: RoleType;
        tabindex?: NumberOrString;
        class: {
            [x: string]: boolean | undefined;
        };
        'data-event-type': string;
    }>;
    /** Renders caption element. */
    render(): VNode[];
}

// File: classes/ClientOnlyInclude.d.ts
/**
 * Manages client-side only rendering.
 */
export declare class ClientOnlyInclude {
    /** Reactive mount state. */
    isMounted: Ref<boolean, boolean>;
    /**
     * Constructor.
     * @param props input data
     */
    constructor(props: ClientOnlyPropsInclude);
    /** Computed rendering readiness. */
    readonly isRender: ComputedRef<boolean>;
    /** Returns rendering state. */
    is(): boolean;
}

// File: classes/DescriptionInclude.d.ts
/**
 * Adds description text.
 */
export declare class DescriptionInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param slots slot object
     * @param skeleton loading state skeleton
     */
    constructor(props: Readonly<DescriptionProps>, className: string, slots?: DescriptionSlots | undefined, skeleton?: SkeletonInclude | undefined);
    /** Checks for description presence. */
    readonly is: ComputedRef<boolean>;
    /** Unique identifier. */
    readonly id: ComputedRef<string>;
    /** Render description. */
    render(): VNode[];
}

// File: classes/EnabledInclude.d.ts
/**
 * Controls item activity state.
 */
export declare class EnabledInclude {
    /**
     * Constructor.
     * @param props input property
     * @param progress progress object
     */
    constructor(props: EnabledProps, progress?: ProgressInclude | undefined);
    /** Checks if active. */
    readonly isEnabled: ComputedRef<boolean>;
    /** Checks if read-only. */
    readonly isReadonly: ComputedRef<boolean>;
    /** Checks if disabled. */
    readonly isDisabled: ComputedRef<boolean>;
    /** Checks if disabled or value empty. */
    readonly isDisabledOrUndefined: ComputedRef<boolean | undefined>;
    /** Aria properties for enabled state. */
    readonly aria: ComputedRef<AriaList>;
}

// File: classes/EventClickInclude.d.ts
/**
 * Manages button events.
 */
export declare class EventClickInclude {
    /**
     * Constructor.
     * @param props input data
     * @param enabled activity status object
     * @param emits event callback
     */
    constructor(props?: EventClickProps | undefined, enabled?: EnabledInclude | undefined, emits?: ConstrEmit<EventClickEmits> | undefined);
    /** Returns element bindings. */
    get binds(): {
        onClick: (event: MouseEvent, options?: EventClickValue) => void;
        onKeydown: (event: KeyboardEvent, options?: EventClickValue) => void;
        href?: string;
    };
    /** Exported values. */
    get expose(): EventClickExpose;
    /** Returns link value. */
    getHref(): ConstrHrefProps;
    /** Click event handler. */
    readonly onClick: (event: MouseEvent, options?: EventClickValue) => void;
    /** Keydown event handler. */
    readonly onKeydown: (event: KeyboardEvent, options?: EventClickValue) => void;
}

// File: classes/Field/FieldArrowInclude.d.ts
/**
 * Manages input arrows.
 */
export declare class FieldArrowInclude {
    /**
     * Constructor.
     * @param props input data
     * @param value value object
     * @param type type object
     */
    constructor(props: FieldAllProps, value: FieldValueInclude, type?: FieldTypeInclude | undefined);
    /** Checks if arrows are enabled. */
    readonly is: ComputedRef<boolean>;
    /** Previous button disabled state. */
    readonly disabledPrevious: ComputedRef<boolean>;
    /** Next button disabled state. */
    readonly disabledNext: ComputedRef<boolean>;
    /** Checks if carousel type. */
    isCarousel(): boolean;
    /** Checks if stepper type. */
    isStepper(): boolean;
    /** Checks if value can decrease. */
    isPrevious(value: number): boolean;
    /** Checks if value can increase. */
    isNext(value: number): boolean;
    /** Returns arrow type. */
    get(): FieldArrowProps['arrow'] | undefined;
    /** Returns arrow alignment. */
    align(): string | undefined;
    /** Decrease value. */
    previous(): this;
    /** Increase value. */
    next(): this;
    /** Set to minimum. */
    toMin(): this;
    /** Set to maximum. */
    toMax(): this;
}

// File: classes/Field/FieldAttributesInclude.d.ts
/**
 * Manages input element attributes.
 */
export declare class FieldAttributesInclude {
    /**
     * Constructor.
     * @param props input data
     * @param type type object
     * @param pattern pattern object
     * @param inputMode keyboard object
     */
    constructor(props: FieldAllProps, type?: FieldTypeInclude | undefined, pattern?: FieldPatternInclude | undefined, inputMode?: FieldInputModeInclude | undefined);
    /** Verification data. */
    readonly list: ComputedRef<Record<string, any>>;
    /** Verification data for checks. */
    readonly listForCheck: ComputedRef<Record<string, any>>;
    /** Attributes for input element. */
    readonly listForInput: ComputedRef<Record<string, any>>;
    /** Attributes for checkbox element. */
    readonly listForCheckbox: ComputedRef<Record<string, any>>;
}

// File: classes/Field/FieldChangeInclude.d.ts
/**
 * Tracks field value change state.
 */
export declare class FieldChangeInclude {
    /** Change state flag. */
    readonly item: Ref<boolean, boolean>;
    /**
     * Constructor.
     * @param props input data
     */
    constructor(props: FieldAllProps);
    /** Returns change state. */
    is(): boolean;
    /**
     * Sets change state.
     * @param change new state
     */
    set(change: boolean): void;
    /** Force change state. */
    to(): void;
}

// File: classes/Field/FieldCodeInclude.d.ts
/**
 * Processes error text.
 */
export declare class FieldCodeInclude {
    /**
     * Constructor.
     * @param props input data
     */
    constructor(props: FieldAllProps);
    /**
     * Returns error text.
     * @param state validity state
     */
    get(state?: ValidityState): string | undefined;
}

// File: classes/Field/FieldElementInclude.d.ts
/**
 * Manages input elements.
 */
export declare class FieldElementInclude {
    /**
     * Constructor.
     * @param props input data
     * @param element input element
     */
    constructor(props: FieldAllProps, element: Ref<FieldElementInput>);
    /** Returns input element. */
    get(): HTMLInputElement | undefined;
    /** Returns element reference. */
    getElement(): Ref<FieldElementInput>;
    /**
     * Find element by name or selector.
     * @param nameSelectors name or selector
     */
    findByName(nameSelectors: string | HTMLInputElement): HTMLInputElement | undefined;
    /** Resets values. */
    clear(): this;
}

// File: classes/Field/FieldEventInclude.d.ts
/**
 * Manages field events.
 */
export declare class FieldEventInclude {
    /**
     * Constructor.
     * @param props input data
     * @param change change label object
     * @param value values object
     * @param validation validity object
     * @param emits event callback
     */
    constructor(props: FieldAllProps, change: FieldChangeInclude, value: FieldValueInclude, validation?: FieldValidationInclude | undefined, emits?: ConstrEmit<FieldBasicEmits> | undefined);
    /** Checks if modification is possible. */
    isEnabled(): boolean;
    /** Blur event handler. */
    readonly onBlur: () => void;
    /** Input event handler. */
    readonly onInput: (event: InputEvent, data?: Record<string, any>) => void;
    /** Change event handler. */
    readonly onChange: (event?: InputEvent | Event) => void;
    /** Select event handler. */
    readonly onSelect: (event: Event, data?: Record<string, any>) => void;
    /** Checked event handler. */
    readonly onChecked: (event: Event) => void;
    /** Radio event handler. */
    readonly onRadio: (event: Event) => void;
    /** Clear event handler. */
    readonly onClear: (event: MouseEvent) => void;
    /** Specific value event handler. */
    readonly onValue: (value: any) => void;
    /** Generic event trigger. */
    readonly on: <E>(event?: E, type?: string & keyof FieldBasicEmits) => this;
}

// File: classes/Field/FieldInputCheckInclude.d.ts
/**
 * Performs native pattern validation via hidden input.
 */
export declare class FieldInputCheckInclude<Value = any> {
    readonly pattern: FieldPatternItemOrFunction;
    readonly group: string;
    /** Hidden input element. */
    readonly input: HTMLInputElement | undefined;
    /**
     * Constructor.
     * @param pattern verification property
     * @param group group name
     * @param code error code object
     */
    constructor(pattern: FieldPatternItemOrFunction, group?: string, code?: FieldCodeInclude | undefined);
    /** Performs check. */
    check(value: Value): FieldValidationItem;
    /** Performs check on input. */
    checkByInput(input: FieldElementDom): FieldValidationItem;
    /** Returns default group. */
    static getGroupDefault(): string;
}
export type FieldInputCheckListInclude = Record<string, FieldInputCheckInclude>;

// File: classes/Field/FieldInputModeInclude.d.ts
/**
 * Determines virtual keyboard type.
 */
export declare class FieldInputModeInclude {
    /**
     * Constructor.
     * @param props input data
     * @param type type object
     */
    constructor(props: FieldAllProps, type: FieldTypeInclude);
    /** Returns keyboard name. */
    readonly item: ComputedRef<string | undefined>;
    readonly autocomplete: ComputedRef<string | undefined>;
}

// File: classes/Field/FieldMatchInclude.d.ts
/**
 * Checks value matching with another element.
 */
export declare class FieldMatchInclude {
    /**
     * Constructor.
     * @param props input data
     * @param element element object
     * @param value value object
     * @param text text object
     */
    constructor(props: FieldAllProps, element: FieldElementInclude, value: FieldValueInclude, text?: TextInclude | undefined);
    /** Checks if enabled. */
    is(): boolean;
    /** Returns target selector. */
    getSelectors(): string | HTMLInputElement | undefined;
    /** Returns validation message. */
    getValidationMessage(): string;
    /** Performs match check. */
    check(): FieldValidationItem | undefined;
}

// File: classes/Field/FieldPatternInclude.d.ts
/**
 * Manages regular expression checks.
 */
export declare class FieldPatternInclude {
    /**
     * Constructor.
     * @param props input data
     * @param type type object
     */
    constructor(props: FieldAllProps, type?: FieldTypeInclude | undefined);
    /** Returns pattern string. */
    readonly item: ComputedRef<string | undefined>;
}

// File: classes/Field/FieldTypeInclude.d.ts
/**
 * Manages input type.
 */
export declare class FieldTypeInclude {
    /**
     * Constructor.
     * @param props input data
     * @param visibility visibility object
     */
    constructor(props: FieldAllProps, visibility?: FieldVisibilityInclude | undefined);
    /** Returns input type. */
    readonly item: ComputedRef<FieldType>;
    /** Returns input type. */
    get(): FieldType;
}

// File: classes/Field/FieldValidationInclude.d.ts
/**
 * Manages field validity.
 */
export declare class FieldValidationInclude {
    /**
     * Constructor.
     * @param props input data
     * @param attributes attribute object
     * @param value value object
     * @param change change object
     * @param code code object
     * @param match match object
     */
    constructor(props: FieldAllProps, attributes: FieldAttributesInclude, value: FieldValueInclude, change?: FieldChangeInclude | undefined, code?: FieldCodeInclude | undefined, match?: FieldMatchInclude | undefined);
    /** Validation data. */
    readonly item: ComputedRef<FieldValidationItem>;
    /** Validation message. */
    readonly message: ComputedRef<string>;
    /** Checks if errored. */
    isError(): boolean;
    /** Performs validity check. */
    readonly checkValidity: () => boolean;
    /** Sets validity data. */
    set(validation: Record<string, any> | FieldValidationItem): this;
}

// File: classes/Field/FieldValueInclude.d.ts
/**
 * Manages input values.
 */
export declare class FieldValueInclude<Value = any> {
    /** Current value. */
    readonly item: Ref<Value | undefined, Value | undefined>;
    /** Full value status. */
    readonly isFull: Ref<boolean, boolean>;
    /**
     * Constructor.
     * @param props input data
     * @param refs reactive data
     * @param element element object
     * @param original original values
     */
    constructor(props: FieldValueProps<Value>, refs: ToRefs<FieldValueProps<Value>>, element?: FieldElementInclude | undefined, original?: RefOrNormal<Value> | undefined);
    /** Checks for any value presence. */
    readonly is: ComputedRef<boolean>;
    /** Checks for explicit value. */
    readonly isValue: ComputedRef<boolean>;
    /** Returns value if complete. */
    readonly itemByFull: ComputedRef<Value | undefined>;
    /** Value as number. */
    readonly number: ComputedRef<number>;
    /** Value as string. */
    readonly string: ComputedRef<string>;
    /** Value as boolean. */
    readonly boolean: ComputedRef<boolean>;
    /** Value length. */
    readonly length: ComputedRef<number>;
    /** Returns value. */
    get(): Value | undefined;
    /** Returns value as array. */
    getToArray(): Value[];
    /** Sets value. */
    set(value: any): this;
    /** Sets value from event. */
    setByEvent(event: Event): this;
    setByEvent(value: Record<string, any>): this;
    setByEvent(value: any): this;
    /** Sets value from target. */
    setByTarget(target: HTMLInputElement): this;
    /** Sets value from checked state. */
    setByChecked(event: Event): this;
    /** Sets radio value. */
    setByRadio(event: Event): this;
    /** Sets full state. */
    setFull(isFull: boolean): void;
    /** Sets editing state. */
    setHasEdit(hasEdit: boolean): void;
    /** Resets to original. */
    setToOriginal(): this;
    /** Resets values. */
    clear(): this;
}

// File: classes/Field/FieldVisibilityInclude.d.ts
/**
 * Manages data visibility (e.g. password toggle).
 */
export declare class FieldVisibilityInclude {
    readonly item: Ref<boolean, boolean>;
    /** Toggles visibility. */
    toggle(): this;
}

// File: classes/LabelHighlightInclude.d.ts
/**
 * Adds text highlighting support.
 */
export declare class LabelHighlightInclude extends LabelInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param classesExtra extra classes
     * @param slots slot object
     * @param elementsExtra extra elements
     * @param skeleton optional skeleton
     */
    constructor(props: Readonly<LabelHighlightProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: LabelHighlightSlots | undefined, elementsExtra?: (() => VNode[]) | undefined, skeleton?: SkeletonInclude | undefined);
    /** Checks if highlighting required. */
    isHighlight(): boolean;
}

// File: classes/LabelInclude.d.ts
/**
 * Adds text labels.
 */
export declare class LabelInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param classesExtra extra classes
     * @param slots slot object
     * @param elementsExtra extra elements
     * @param labelReplacing replacement label
     * @param alternativeSlots use alternative slots
     * @param skeleton optional skeleton
     * @param tag HTML tag
     */
    constructor(props: Readonly<LabelProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: (LabelSlots | LabelAlternativeSlots) | undefined, elementsExtra?: (() => VNode[]) | undefined, labelReplacing?: Ref<string | number | undefined> | undefined, alternativeSlots?: boolean | undefined, skeleton?: SkeletonInclude | undefined, tag?: RefOrNormal<string>);
    /** Checks label presence. */
    readonly is: ComputedRef<boolean>;
    /** Element ID. */
    readonly id: ComputedRef<string>;
    /** Render label. */
    render(childrenExtra?: any[], props?: Record<string, any>): VNode[];
}

// File: classes/LabelNumberInclude.d.ts
/**
 * Manages numeric labels with max constraints.
 */
export declare class LabelNumberInclude extends LabelInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param classesExtra extra classes
     * @param slots slot object
     * @param elementsExtra extra elements
     * @param skeleton optional skeleton
     */
    constructor(props: Readonly<LabelNumberProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: LabelNumberSlots | undefined, elementsExtra?: (() => VNode[]) | undefined, skeleton?: SkeletonInclude | undefined);
}

// File: classes/ModelInclude.d.ts
/**
 * Manages model synchronization and event emission.
 */
export declare class ModelInclude<Value = string> {
    /**
     * Constructor.
     * @param index property key
     * @param emits emission function
     * @param syncValue reactive value
     */
    constructor(index: string, emits?: any | undefined, syncValue?: RefType<Value> | undefined);
    /** Checks if value is mutable Ref. */
    isValue(): this is {
        syncValue: Ref<Value>;
    };
    /** Generates v-model bindings. */
    getBinds(): {
        [x: string]: Value | ((value: Value) => void);
    };
    /** Updates sync value. */
    readonly update: (value: Value) => void;
    /** Emits update event. */
    emit(value: Value): void;
}

// File: classes/ModelValueInclude.d.ts
/**
 * Manages model value with click handling.
 */
export declare class ModelValueInclude<Value = any> {
    readonly value: Ref<Value | undefined, Value | undefined>;
    /**
     * Constructor.
     * @param index ID
     * @param emits emission function
     * @param event click handler
     * @param inputValue value ref
     * @param readonly readonly flag
     */
    constructor(index: string, emits?: any | undefined, event?: EventClickInclude | undefined, inputValue?: RefType<any> | undefined, readonly?: RefType<boolean | undefined> | undefined);
    /** Returns current value. */
    getValue(): Value | undefined;
    /** Click event handler. */
    readonly onClick: (event: MouseEvent, options?: EventClickValue) => void;
}

// File: classes/Plugin/Plugin.d.ts
/**
 * Vite plugin base class.
 */
export declare class Plugin {
    /**
     * Constructor.
     * @param design design system
     * @param packageName package name
     * @param componentsReg component regex
     * @param styleVarsReg style variables regex
     * @param componentsList component list
     * @param name plugin name
     * @param options options
     */
    constructor(design: string, packageName: string, componentsReg: RegExp, styleVarsReg: RegExp, componentsList: PluginComponentImports, name?: string, options?: PluginOptions);
    /** Initializes plugin. */
    init(): VitePlugin;
}

// File: classes/Plugin/PluginCode.d.ts
/**
 * Manages plugin code transformations.
 */
export declare class PluginCode {
    /**
     * Constructor.
     * @param id file ID
     * @param code source code
     */
    constructor(id: string, code: string);
    /** Checks if Vue file. */
    isVue(): boolean;
    /** Checks if SCSS file. */
    isScss(): boolean;
    /** Returns modified code. */
    get(): string;
    /** Returns file ID. */
    getId(): string;
    /** Returns original code. */
    getCode(): string;
    /** Checks code presence. */
    has(pattern: string | RegExp, flags?: string): boolean;
    /** Adds code after script tag. */
    addAfterScript(code: string): this;
    /** Adds code to start. */
    addStart(code: string): this;
    /** Adds code to start if missing. */
    addStartIfNone(code: string, pattern?: string | RegExp): this;
    /** Replaces code fragment. */
    replace(pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string)): this;
}

// File: classes/Plugin/PluginComponents.d.ts
/**
 * Connects components.
 */
export declare class PluginComponents {
    /**
     * Constructor.
     * @param code plugin code
     * @param pluginData plugin data
     */
    constructor(code: PluginCode, pluginData: PluginData);
    /** Initializes data. */
    make(): void;
}

// File: classes/Plugin/PluginData.d.ts
/**
 * Stores plugin data.
 */
export declare class PluginData {
    /**
     * Constructor.
     * @param design design name
     * @param packageName package name
     * @param componentsReg component regex
     * @param styleVarsReg style regex
     * @param componentsList component list
     */
    constructor(design: string, packageName: string, componentsReg: RegExp, styleVarsReg: RegExp, componentsList: PluginComponentImports);
    /** Checks code for component. */
    hasComponent(code: string): boolean;
    /** Checks code for variables. */
    hasVars(code: string): boolean;
    /** Returns design name. */
    getDesign(): string;
    /** Returns package name. */
    getPackageName(): string;
    /** Returns found components. */
    getComponents(code: string): PluginComponentImports;
    /** Returns style regex. */
    getStyleVarsReg(): RegExp;
    /** Returns style modification map. */
    getStyleModification(): Record<string, string>;
}

// File: classes/Plugin/PluginImport.d.ts
/**
 * Plugin import manager.
 */
export declare class PluginImport {
    /**
     * Constructor.
     * @param packageName package name
     * @param code file content
     */
    constructor(packageName: string, code: string);
    /** Returns content. */
    get(): string;
    /** Connects styles. */
    importStyle(): this;
}

// File: classes/Plugin/PluginStyle.d.ts
/**
 * Transforms non-standard style properties.
 */
export declare class PluginStyle {
    /**
     * Constructor.
     * @param code plugin code
     * @param data plugin data
     */
    constructor(code: PluginCode, data: PluginData);
    /** Starts transformation. */
    make(): this;
}

// File: classes/Plugin/PluginTool.d.ts
/**
 * Utility for plugin data.
 */
export declare class PluginTool {
    /** Checks if user file ID. */
    static isSrc(id: string): boolean;
    /** Checks if JS file ID. */
    static isJs(id: string): boolean;
    /** Checks if Vue file ID. */
    static isVue(id: string): boolean;
    /** Checks if style file ID. */
    static isCss(id: string): boolean;
    /** Checks development mode. */
    static isDev(mode: string): boolean;
}

// File: classes/PrefixInclude.d.ts
/**
 * Manages prefix content.
 */
export declare class PrefixInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param slots slot object
     * @param skeleton optional skeleton
     */
    constructor(props: Readonly<PrefixProps>, className: string, slots?: PrefixSlots | undefined, skeleton?: SkeletonInclude | undefined);
    /** Checks if prefix filled. */
    readonly is: ComputedRef<boolean>;
    /** Unique identifier. */
    readonly id: ComputedRef<string>;
    /** Returns describedby ID if element exists. */
    readonly describedby: ComputedRef<string>;
    /** Renders prefix. */
    render(): VNode[];
}

// File: classes/ScrollToXInclude.d.ts
/**
 * Manages horizontal scrolling.
 */
export declare class ScrollToXInclude {
    /**
     * Constructor.
     * @param element target element
     */
    constructor(element: Ref<HTMLElement | undefined>);
    /** Returns element bindings. */
    readonly binds: ComputedRef<{
        onWheelPassive: (event: WheelEvent) => void;
    }>;
    /** Wheel event handler. */
    readonly onScrollToX: (event: WheelEvent) => void;
}

// File: classes/SuffixInclude.d.ts
/**
 * Manages suffix content.
 */
export declare class SuffixInclude {
    /**
     * Constructor.
     * @param props input property
     * @param className class name
     * @param slots slot object
     * @param skeleton optional skeleton
     */
    constructor(props: Readonly<SuffixProps>, className: string, slots?: SuffixSlots | undefined, skeleton?: SkeletonInclude | undefined);
    /** Checks if suffix filled. */
    readonly is: ComputedRef<boolean>;
    /** Unique identifier. */
    readonly id: ComputedRef<string>;
    /** Returns describedby ID if element exists. */
    readonly describedby: ComputedRef<string>;
    /** Renders suffix. */
    render(): VNode[];
}

// File: classes/TabIndexInclude.d.ts
/**
 * Manages focus and tab index.
 */
export declare class TabIndexInclude<E extends HTMLElement = HTMLElement> {
    /**
     * Constructor.
     * @param element element reference
     * @param active return focus flag
     * @param activeOpen active on opening
     * @param activeClose active on closing
     */
    constructor(element: Ref<E | undefined> | (() => E | undefined), active?: () => boolean, activeOpen?: () => boolean, activeClose?: () => boolean);
    /** Sets focus. */
    goTo(): this;
    /** Resets focus to previous. */
    reset(): this;
    /** Toggles focus state. */
    toggle(status: boolean): this;
    /** Saves current focus. */
    updateOldElement(): void;
    /** Find first focusable. */
    findFirstElement(): HTMLElement | undefined;
    /** Find last focusable. */
    findLastElement(): HTMLElement | undefined;
}

// File: classes/TextInclude.d.ts
/**
 * Manages text-related properties.
 */
export declare class TextInclude {
    /** Global text list. */
    static readonly list: ShallowRef<TextList, TextList>;
    readonly texts: Record<string, ComputedRef<string | undefined>>;
    /**
     * Initializes global texts.
     * @param texts text list
     */
    static initText(texts: TextList): void;
    /**
     * Constructor.
     * @param props component properties
     */
    constructor(props: TextAllPropsInclude);
    get cancel(): ComputedRef<string | undefined>;
    get characterLimit(): ComputedRef<string | undefined>;
    get characterRemaining(): ComputedRef<string | undefined>;
    get close(): ComputedRef<string | undefined>;
    get copiedClipboard(): ComputedRef<string | undefined>;
    get decrement(): ComputedRef<string | undefined>;
    get entriesMatch(): ComputedRef<string | undefined>;
    get hide(): ComputedRef<string | undefined>;
    get increment(): ComputedRef<string | undefined>;
    get loading(): ComputedRef<string | undefined>;
    get next(): ComputedRef<string | undefined>;
    get notifications(): ComputedRef<string | undefined>;
    get ok(): ComputedRef<string | undefined>;
    get previous(): ComputedRef<string | undefined>;
    get show(): ComputedRef<string | undefined>;
    /** Get text by property name. */
    get(name: keyof TextAllPropsInclude): ComputedRef<string | undefined>;
}

// File: classes/TouchEventInclude.d.ts
/**
 * Handles touch and mouse gestures.
 */
export declare class TouchEventInclude {
    /** Current touch. */
    readonly touche: Ref<Touch | undefined, Touch | undefined>;
    /** Move touch. */
    readonly toucheMove: Ref<Touch | undefined, Touch | undefined>;
    /** Current mouse. */
    readonly mouse: Ref<TouchEventClient | undefined, TouchEventClient | undefined>;
    /** Move mouse. */
    readonly mouseMove: Ref<TouchEventClient | undefined, TouchEventClient | undefined>;
    /**
     * Constructor.
     * @param start start callback
     * @param move move callback
     * @param end end callback
     * @param element target element
     */
    constructor(start?: ((mouse: TouchEventClient, touche?: Touch) => void) | undefined, move?: TouchEventCallback | undefined, end?: TouchEventCallback | undefined, element?: Ref<HTMLElement | undefined> | undefined);
    /** Touch event handlers. */
    readonly onTouch: {
        onTouchstart: (event: TouchEvent) => void;
        onTouchend: (event: TouchEvent) => void;
        onTouchcancel: (event: TouchEvent) => void;
        onTouchmove: (event: TouchEvent) => void;
    };
    /** Mouse event handlers. */
    readonly onMouse: {
        onMousedown: (event: MouseEvent) => void;
        onMouseup: (event: MouseEvent) => void;
        onMousemove: (event: MouseEvent) => void;
    };
}

// File: constructors/Accordion/basicTypes.d.ts
export {};

// File: constructors/Accordion/props.d.ts
export type AccordionPropsToken = {
    divider?: boolean;
};
export type AccordionPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Cell extends CellPropsBasic = CellPropsBasic, MotionTransform extends MotionTransformPropsBasic = MotionTransformPropsBasic> = LabelProps & DescriptionProps & IconLitePropsInclude<Icon> & MotionTransformPropsInclude<MotionTransform> & ModelPropsOpen & {
    /** Cell attributes. */
    cellAttrs?: ConstrBind<Cell>;
    /** Dropdown icon. */
    iconArrowDown?: IconValue<Icon>;
};
export type AccordionProps = AccordionPropsBasic & AccordionPropsToken;
export declare const defaultsAccordion: {
    divider: boolean;
    clickOpen: boolean;
    autoClose: boolean;
};

// File: constructors/Accordion/types.d.ts
export type AccordionComponents = CellComponentInclude & MotionTransformComponentInclude;
export type AccordionEmits = EventClickEmits & MotionTransformEmitsInclude & ModelEmitsOpen;
export interface AccordionExpose extends MotionTransformExposeInclude {
}
export interface AccordionSlots extends CellSlotsInclude {
    /** Default accordion content. */
    default?(props: MotionTransformControlItem): any;
}
export type AccordionClasses = {
    main: ConstrClass;
    head: string;
    body: string;
};

// File: constructors/ActionSheet/basicTypes.d.ts
export {};

// File: constructors/ActionSheet/props.d.ts
export type ActionSheetPropsToken = {};
export type ActionSheetPropsBasic<Window extends WindowPropsBasic = WindowPropsBasic, Bars extends BarsPropsBasic = BarsPropsBasic, Actions extends ActionsPropsBasic = ActionsPropsBasic> = WindowPropsInclude<Window> & BarsPropsInclude<Bars> & ActionsPropsInclude<Actions> & {
    /** Visibility. */
    open?: boolean;
    /** Close on touch. */
    touchClose?: boolean;
};
export type ActionSheetProps = ActionSheetPropsBasic & ActionSheetPropsToken;
export declare const defaultsActionSheet: {
    barsBackHide: boolean;
    touchClose: boolean;
};

// File: constructors/ActionSheet/types.d.ts
export type ActionSheetComponents = ModalComponents;
export type ActionSheetEmits = ModalEmits;
export interface ActionSheetExpose extends ModalExpose {
}
export interface ActionSheetSlots extends ModalSlots {
}
export type ActionSheetClasses = {
    main: ConstrClass;
    title: string;
    header: string;
    body: string;
    footer: string;
    touch: string;
    tab: string;
};

// File: constructors/Actions/basicTypes.d.ts
/** Actions connection map. */
export type ActionsComponentInclude = {
    actions?: object;
};
/** Included events. */
export type ActionsEmitsInclude = {
    actions: EventClickEmits['click'];
    actionsLite: EventClickEmits['clickLite'];
};
/** Connection properties. */
export type ActionsPropsInclude<Actions extends ActionsPropsBasic = ActionsPropsBasic> = {
    actionsHide?: boolean;
    actionsList?: ConstrBind<Actions['list']>;
    actionsSecondary?: ConstrBind<Actions['listSecondary']>;
    actionsAttrs?: ConstrBind<Actions>;
};

// File: constructors/Actions/props.d.ts
export type ActionsPropsToken = {
    align?: string | 'none' | 'center' | 'left' | 'right' | 'block' | 'auto';
    flexible?: boolean;
    wrap?: boolean;
};
export type ActionsPropsBasic<Button extends ButtonPropsBasic = ButtonPropsBasic> = AreaProps & {
    /** Primary buttons. */
    list?: ConstrBind<Button>[];
    /** Secondary buttons. */
    listSecondary?: ConstrBind<Button>[];
    /** Global attributes for primary list. */
    buttonAttrs?: ConstrBind<Button>;
    /** Global attributes for secondary list. */
    buttonSecondaryAttrs?: ConstrBind<Button>;
};
export type ActionsProps = ActionsPropsBasic & ActionsPropsToken;
export declare const defaultsActions: {
    align: string;
    area: string;
};

// File: constructors/Actions/types.d.ts
export type ActionsComponents = ButtonComponentInclude;
export type ActionsEmits = EventClickEmits;
export interface ActionsExpose {
}
export interface ActionsSlots {
    /** Primary list slot. */
    default?(props: any): any;
    /** Secondary list slot. */
    secondary?(props: any): any;
}
export type ActionsClasses = {
    main: ConstrClass;
    item: string;
    list: string;
    secondary: string;
    spacer: string;
};

// File: constructors/Anchor/basicTypes.d.ts
/** Anchor scroll behavior. */
export type AnchorScrollProps = {
    /** Position shift. */
    shift?: NumberOrString;
    /** Transition behavior. */
    behavior?: ScrollIntoViewOptions['behavior'];
    /** Vertical alignment. */
    block?: ScrollIntoViewOptions['block'];
    /** Horizontal alignment. */
    inline?: ScrollIntoViewOptions['inline'];
};

// File: constructors/Anchor/props.d.ts
export type AnchorPropsToken = {};
export type AnchorPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Tooltip extends TooltipProps = TooltipProps> = LabelProps & TooltipPropsInclude<Tooltip> & TextCopiedClipboardPropsInclude & AnchorScrollProps & {
    /** Hide flag. */
    hide?: boolean;
    /** Anchor name. */
    name?: string;
    /** Enable copy. */
    isCopy?: boolean;
    /** Link icon. */
    iconLink?: IconValue<Icon>;
    /** Tag icon. */
    iconTag?: IconValue<Icon>;
    /** Copy icon. */
    iconContentCopy?: IconValue<Icon>;
    /** Hide delay. */
    delayHide?: number;
};
export type AnchorProps = AnchorPropsBasic & AnchorPropsToken;
export declare const defaultsAnchor: {
    shift: number;
    delayHide: number;
};

// File: constructors/Anchor/types.d.ts
export type AnchorComponents = TooltipComponentInclude & IconComponentInclude;
export type AnchorEmits = {};
export interface AnchorExpose {
    /** Go to target. */
    go(): void;
}
export interface AnchorSlots extends LabelSlots {
}
export type AnchorClasses = {
    main: ConstrClass;
    label: string;
};

// File: constructors/Area/basicTypes.d.ts
export {};

// File: constructors/Area/props.d.ts
export type AreaPropsBasic = {
    areaDefault?: string;
};
export type AreaProps = AreaPropsBasic;
export declare const defaultsArea: {};

// File: constructors/Area/types.d.ts
export type AreaComponents = {};
export type AreaEmits = {};
export interface AreaExpose {
}
export type AreaSlots = Record<string, (props: any) => any>;
export type AreaClasses = {
    main: ConstrClass;
};

// File: constructors/Arrow/basicTypes.d.ts
/** Arrow direction. */
export declare enum ArrowDirection {
    TOP = "top",
    BOTTOM = "bottom",
    LEFT = "left",
    RIGHT = "right",
    HIDE = "hide"
}
/** Border offsets. */
export type ArrowBorder = {
    top: number;
    bottom: number;
    left: number;
    right: number;
};
/** Center coordinates. */
export type ArrowCenter = {
    x: number;
    y: number;
};
/** Connection map. */
export type ArrowComponentInclude = {
    arrow?: object;
};
/** Included properties. */
export type ArrowPropsInclude<Arrow extends ArrowProps = ArrowProps> = {
    arrowShow?: boolean;
    arrowPosition?: ArrowProps['position'];
    arrowAttrs?: ConstrBind<Arrow>;
};

// File: constructors/Arrow/props.d.ts
export type ArrowPropsToken = {
    position?: string | 'auto' | 'top' | 'bottom' | 'left' | 'right';
    inverse?: boolean;
};
export type ArrowPropsBasic = {
    /** Target element. */
    elementTarget?: HTMLElement | string;
};
export type ArrowProps = ArrowPropsBasic & ArrowPropsToken;
export declare const defaultsArrow: {
    position: string;
};

// File: constructors/Arrow/types.d.ts
export type ArrowComponents = {};
export type ArrowEmits = {};
export interface ArrowExpose {
    /** Update position. */
    update: () => void;
}
export interface ArrowSlots {
}
export type ArrowClasses = {
    main: ConstrClass;
    mask: string;
    arrow: string;
    arrowLine: string;
    arrowArea: string;
    border: string;
    borderHidden: string;
};

// File: constructors/Badge/basicTypes.d.ts
/** Connection map. */
export type BadgeComponentInclude = {
    badge?: object;
};
/** Included properties. */
export type BadgePropsInclude<Badge extends BadgePropsBasic = BadgePropsBasic> = {
    badge?: string | number | ConstrBind<Badge>;
    badgeDot?: boolean;
};

// File: constructors/Badge/props.d.ts
export type BadgePropsToken = {
    selected?: boolean;
    hide?: boolean;
    dot?: boolean;
    overlap?: string | 'rectangular' | 'circular' | 'static';
    vertical?: string | 'top' | 'center' | 'bottom';
    horizontal?: string | 'right' | 'center' | 'left';
};
export type BadgePropsBasic<Icon extends IconPropsBasic = IconPropsBasic> = IconPropsInclude<Icon> & LabelNumberProps & AriaLabelPropsInclude & {
    /** Point mode. */
    dot?: boolean;
};
export type BadgeProps = BadgePropsBasic & BadgePropsToken;
export declare const defaultsBadge: {
    overlap: string;
    vertical: string;
    horizontal: string;
};

// File: constructors/Badge/types.d.ts
export type BadgeComponents = IconComponentInclude;
export type BadgeEmits = {};
export interface BadgeExpose {
}
export interface BadgeSlots extends LabelNumberSlots {
}
export type BadgeClasses = {
    main: ConstrClass;
    label: string;
    icon: string;
};

// File: constructors/Bars/basicTypes.d.ts
/** Connection map. */
export type BarsComponentInclude = {
    bars?: object;
};
/** Included events. */
export type BarsEmitsInclude = {
    bars: EventClickEmits['click'];
    barsLite: EventClickEmits['clickLite'];
    barsBack: EventClickEmits['clickLite'];
};
/** Included properties. */
export type BarsPropsInclude<Bars extends BarsPropsBasic = BarsPropsBasic> = {
    barsLabel?: string | number;
    barsDescription?: string;
    barsBackHide?: boolean;
    barsHide?: boolean;
    barsList?: Bars['bars'];
    barsAttrs?: ConstrBind<Bars>;
};

// File: constructors/Bars/props.d.ts
export type BarsPropsToken = {};
export type BarsPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Button extends ButtonPropsBasic = ButtonPropsBasic> = LabelProps & DescriptionProps & SkeletonPropsInclude & TextClosePropsInclude & {
    /** Action mode state. */
    'action'?: boolean;
    /** Back button props. */
    'backButton'?: ConstrBind<Button>;
    /** Hide back button. */
    'backHide'?: boolean;
    /** Hide back in action. */
    'backActionHide'?: boolean;
    /** Buttons list. */
    'bars'?: ConstrBind<Button>[];
    /** Action label. */
    'actionLabel'?: LabelProps['label'];
    /** Action description. */
    'actionDescription'?: DescriptionProps['description'];
    /** Action buttons list. */
    'actionBars'?: ConstrBind<Button>[];
    /** Button attributes. */
    'buttonAttrs'?: ConstrBind<Button>;
    /** Back icon. */
    'iconBack'?: IconValue<Icon>;
    /** Close icon. */
    'iconClose'?: IconValue<Icon>;
    /** Action mode model. */
    'modelAction'?: boolean;
};
export type BarsProps = BarsPropsBasic & BarsPropsToken;
export declare const defaultsBars: {};

// File: constructors/Bars/types.d.ts
export type BarsComponents = ButtonComponentInclude;
export type BarsEmits = EventClickEmits & {
    'update:action': [value: boolean];
    'update:modelAction': [value: boolean];
};
export interface BarsExpose {
}
export interface BarsSlots extends LabelSlots, DescriptionSlots {
    /** Buttons slot. */
    bars?(props: any): any;
    /** Action buttons slot. */
    actionBars?(props: any): any;
}
export type BarsClasses = {
    main: ConstrClass;
    context: string;
    label: string;
    description: string;
};

// File: constructors/Block/basicTypes.d.ts
export {};

// File: constructors/Block/props.d.ts
export type BlockPropsToken = {};
export type BlockPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Header extends HeaderPropsBasic = HeaderPropsBasic> = HeaderPropsInclude<Icon, Header> & DescriptionProps & AreaProps & {
    /** Headline text. */
    headline?: string;
    /** Container tag. */
    tag?: string;
};
export type BlockProps = BlockPropsBasic & BlockPropsToken;
export declare const defaultsBlock: {
    area: string;
    tag: string;
    tagHeader: string;
};

// File: constructors/Block/types.d.ts
export type BlockComponents = HeaderComponentInclude;
export type BlockEmits = {};
export interface BlockExpose {
}
export interface BlockSlots extends HeaderSlotsInclude, DescriptionSlots {
    headline?(props: any): any;
    default?(props: any): any;
}
export type BlockClasses = {
    main: ConstrClass;
    headline: string;
    header: string;
    description: string;
    body: string;
};

// File: constructors/Button/basicTypes.d.ts
/** Connection map. */
export type ButtonComponentInclude = {
    button?: object;
};
/** Connection properties. */
export type ButtonPropsInclude<Button extends ButtonPropsBasic = ButtonPropsBasic> = {
    buttonAttrs?: ConstrBind<Button>;
};

// File: constructors/Button/props.d.ts
export type ButtonPropsToken = {
    focus?: boolean;
    disabled?: boolean;
    selected?: boolean;
    readonly?: boolean;
    adaptive?: string | 'iconAlways' | 'block' | 'auto';
    container?: boolean;
    inverse?: boolean;
    grid?: boolean;
    textAlign?: string | 'left' | 'center' | 'right';
};
export type ButtonPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = LabelProps & EnabledProps & IconTrailingPropsInclude<Icon> & ProgressPropsInclude<Progress> & SkeletonPropsInclude & EventClickProps & ConstrHrefProps & AriaLabelPropsInclude & {
    /** HTML tag. */
    tag?: 'button' | 'a' | 'span' | string;
    /** HTML type. */
    type?: 'button' | 'submit' | 'reset' | string;
};
export type ButtonProps = ButtonPropsBasic & ButtonPropsToken;
export declare const defaultsButton: {};

// File: constructors/Button/types.d.ts
export type ButtonComponents = IconComponentInclude & ProgressComponentInclude & RippleComponentInclude;
export type ButtonEmits = EventClickEmits;
export interface ButtonExpose extends EventClickExpose {
}
export interface ButtonSlots extends LabelSlots {
}
export type ButtonClasses = {
    main: ConstrClass;
    label: string;
    icon: string;
    trailing: string;
    loading: string;
};

// File: constructors/Cell/basicTypes.d.ts
/** Sub-element classes. */
export type CellClassesSub = {
    label: string;
    description: string;
    caption: string;
    trailing: string;
};
/** Connection map. */
export type CellComponentInclude = {
    cell?: object;
};
/** Included slots. */
export interface CellSlotsInclude extends LabelAlternativeSlots, DescriptionSlots, CaptionSlots {
    trailing?(props: CellClassesSub): any;
    body?(props: CellClassesSub): any;
}

// File: constructors/Cell/props.d.ts
export type CellPropsToken = {
    focus?: boolean;
    selected?: boolean;
    readonly?: boolean;
    disabled?: boolean;
    dynamic?: boolean;
    dynamicHover?: boolean;
    divider?: boolean;
    dividerLabel?: string | 'always' | 'none';
    iconTop?: boolean;
};
export type CellPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = LabelProps & DescriptionProps & CaptionProps & EnabledProps & IconTrailingPropsInclude<Icon> & ProgressPropsInclude<Progress> & SkeletonPropsInclude & EventClickProps & AriaRolePropsInclude & {
    /** HTML tag. */
    tag?: string;
    /** Show divider. */
    divider?: boolean;
    /** Dynamic behavior flag. */
    dynamic?: boolean;
};
export type CellProps = CellPropsBasic & CellPropsToken;
export declare const defaultsCell: {
    divider: boolean;
    tag: string;
};

// File: constructors/Cell/types.d.ts
export type CellComponents = IconComponentInclude & ProgressComponentInclude & RippleComponentInclude;
export type CellEmits = EventClickEmits;
export interface CellExpose extends EventClickExpose {
}
export interface CellSlots extends LabelSlots, DescriptionSlots, CaptionSlots {
    trailing?(props: CellClassesSub): any;
    body?(props: CellClassesSub): any;
}
export type CellClasses = {
    main: ConstrClass;
    context: string;
    contextTrailing: string;
    label: string;
    description: string;
    caption: string;
    icon: string;
    trailing: string;
    body: string;
    loading: string;
};

// File: constructors/Checkbox/basicTypes.d.ts
export {};

// File: constructors/Checkbox/props.d.ts
export type CheckboxPropsBasic<Image extends ImagePropsBasic = ImagePropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = LabelProps & DescriptionProps & FieldMessagePropsInclude<FieldMessage, FieldCounter> & FieldInputCheckProps & ProgressPropsInclude<Progress> & EnabledProps & ModelProps<boolean> & SkeletonPropsInclude & {
    /** Checked icon. */
    iconCheckbox?: string | ConstrBind<Image> | null;
    /** Indeterminate icon. */
    iconIndeterminate?: string | ConstrBind<Image> | null;
};
export type CheckboxProps = CheckboxPropsBasic & {
    block?: boolean;
    adaptive?: string | 'rightAlways';
    container?: boolean;
    required?: boolean;
    itemCenter?: boolean;
    focus?: boolean;
    disabled?: boolean;
};
export declare const defaultsCheckbox: {
    block: boolean;
    itemCenter: boolean;
    valueVariantHide: string;
};

// File: constructors/Checkbox/types.d.ts
export type CheckboxComponents = ImageComponentInclude & FieldMessageComponentInclude & ProgressComponentInclude & RippleComponentInclude;
export type CheckboxEmits = FieldBasicEmits<boolean>;
export interface CheckboxExpose extends FieldBasicExpose<boolean> {
}
export interface CheckboxSlots extends LabelSlots, DescriptionSlots {
}
export type CheckboxClasses = {
    main: ConstrClass;
    input: string;
    body: string;
    item: string;
    icon: string;
    loading: string;
    info: string;
    label: string;
};

// File: constructors/Chip/basicTypes.d.ts
/** Connection map. */
export type ChipComponentInclude = {
    chip?: object;
};
/** Connection props. */
export type ChipPropsInclude<Chip extends ChipPropsBasic = ChipPropsBasic> = {
    chipAttrs?: ConstrBind<Chip>;
};

// File: constructors/Chip/props.d.ts
export type ChipPropsToken = {
    focus?: boolean;
    disabled?: boolean;
    selected?: boolean;
    readonly?: boolean;
    adaptive?: string | 'iconAlways' | 'block' | 'auto';
    container?: boolean;
    inverse?: boolean;
    grid?: boolean;
    textAlign?: string | 'left' | 'center' | 'right';
};
export type ChipPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = ButtonPropsBasic<Icon, Progress>;
export type ChipProps = ChipPropsBasic & ChipPropsToken;
export declare const defaultsChip: {
    tag: string;
};

// File: constructors/Chip/types.d.ts
export type ChipComponents = ButtonComponents;
export type ChipEmits = ButtonEmits;
export interface ChipExpose extends ButtonExpose {
}
export interface ChipSlots extends ButtonSlots {
}
export type ChipClasses = {
    main: ConstrClass;
    label: string;
    icon: string;
    trailing: string;
    loading: string;
};

// File: constructors/ChipGroup/basicTypes.d.ts
export type ChipGroupData<Chip extends ChipPropsBasic = ChipPropsBasic> = ListListInput<Chip>;
export type ChipGroupItem<Chip extends ChipPropsBasic = ChipPropsBasic> = ConstrBind<Chip>;
export type ChipGroupList<Chip extends ChipPropsBasic = ChipPropsBasic> = ChipGroupItem<Chip>[];

// File: constructors/ChipGroup/props.d.ts
export type ChipGroupPropsToken = {};
export type ChipGroupPropsBasic<Chip extends ChipPropsBasic = ChipPropsBasic> = ModelPropsSelected<ListSelectedList> & {
    /** Read-only state. */
    readonly?: boolean;
    /** Selected list. */
    selected?: ListSelectedList;
    /** Chips data list. */
    list?: ChipGroupData;
    /** Icon on selection. */
    iconWhenSelected?: boolean;
    /** Label key in data. */
    keyLabel?: string;
    /** Value key in data. */
    keyValue?: string;
    /** Chip attributes. */
    chipAttrs?: ConstrBind<Chip>;
};
export type ChipGroupProps = ChipGroupPropsBasic & ChipGroupPropsToken;
export declare const defaultsChipGroup: {
    readonly: boolean;
};

// File: constructors/ChipGroup/types.d.ts
export type ChipGroupComponents = ChipComponentInclude;
export type ChipGroupEmits = EventClickEmits & ModelEmitsSelected<ListSelectedList>;
export interface ChipGroupExpose {
}
export interface ChipGroupSlots {
    default?(props: any): any;
}
export type ChipGroupClasses = {
    main: ConstrClass;
    item: string;
};

// File: constructors/ClientOnly/basicTypes.d.ts
export {};

// File: constructors/ClientOnly/props.d.ts
export type ClientOnlyPropsBasic = ClientOnlyPropsInclude;
export type ClientOnlyProps = ClientOnlyPropsBasic;
export declare const defaultsClientOnly: {
    clientOnly: boolean;
};

// File: constructors/ClientOnly/types.d.ts
export type ClientOnlyComponents = {};
export type ClientOnlyEmits = {};
export interface ClientOnlyExpose {
}
export interface ClientOnlySlots {
    default?(props: any): any;
}
export type ClientOnlyClasses = {
    main: ConstrClass;
};

// File: constructors/Container/basicTypes.d.ts
export {};

// File: constructors/Container/props.d.ts
export type ContainerPropsToken = {
    align?: string | 'left' | 'center' | 'right';
};
export type ContainerPropsBasic = AreaProps;
export type ContainerProps = ContainerPropsBasic & ContainerPropsToken;
export declare const defaultsContainer: {
    align: string;
    area: string;
};

// File: constructors/Container/types.d.ts
export type ContainerComponents = {};
export type ContainerEmits = {};
export interface ContainerExpose {
}
export interface ContainerSlots {
    default?(props: any): any;
}
export type ContainerClasses = {
    main: ConstrClass;
};

// File: constructors/Dialog/basicTypes.d.ts
export {};

// File: constructors/Dialog/props.d.ts
export type DialogPropsToken = {
    success?: boolean;
    error?: boolean;
    imagePosition?: string | 'top' | 'left';
};
export type DialogPropsBasic<Window extends WindowPropsBasic = WindowPropsBasic, Bars extends BarsPropsBasic = BarsPropsBasic, Icon extends IconPropsBasic = IconPropsBasic, Image extends ImagePropsBasic = ImagePropsBasic, Button extends ButtonPropsBasic = ButtonPropsBasic, Actions extends ActionsPropsBasic = ActionsPropsBasic> = WindowPropsInclude<Window> & BarsPropsInclude<Bars> & ActionsPropsInclude<Actions> & ImagePropsInclude<Image> & LabelProps & DescriptionProps & TextClosePropsInclude & TextOkPropsInclude & {
    /** Open state. */
    open?: boolean;
    /** Dialog icon. */
    icon?: IconValue<Icon>;
    /** OK button props. */
    buttonOk?: string | ConstrBind<Button> | null;
    /** Close button props. */
    buttonClose?: string | ConstrBind<Button> | null;
    /** Show close button. */
    closeButton?: boolean;
    /** Close on OK. */
    clickOkAndClose?: boolean;
    /** Success icon. */
    iconSuccess?: IconValue<Icon>;
    /** Error icon. */
    iconError?: IconValue<Icon>;
    /** Icon attributes. */
    iconAttrs?: ConstrBind<Icon>;
};
export type DialogProps = DialogPropsBasic & DialogPropsToken;
export declare const defaultsDialog: {
    imagePosition: string;
    barsBackHide: boolean;
    barsHide: boolean;
    clickOkAndClose: boolean;
};

// File: constructors/Dialog/types.d.ts
export type DialogComponents = ModalComponents & IconComponentInclude;
export type DialogEmits = ModalEmits & {
    ok: [];
    close: [];
};
export interface DialogExpose extends ModalExpose {
}
export interface DialogSlots extends ModalSlots, LabelAlternativeSlots, DescriptionSlots {
}
export type DialogClasses = {
    main: ConstrClass;
    title: string;
    header: string;
    information: string;
    icon: string;
    label: string;
    description: string;
    body: string;
    footer: string;
};

// File: constructors/Dummy/basicTypes.d.ts
export {};

// File: constructors/Dummy/props.d.ts
export type DummyPropsBasic = {};
export type DummyProps = DummyPropsBasic;
export declare const defaultsDummy: {};

// File: constructors/Dummy/types.d.ts
export type DummyComponents = {};
export type DummyEmits = {};
export interface DummyExpose {
}
export interface DummySlots {
    default?(props: any): any;
}
export type DummyClasses = {
    main: ConstrClass;
};

// File: constructors/Field/basicTypes.d.ts
/** Data passed to field slots. */
export type FieldControl = {
    id: string;
    className: string;
    classHidden: string;
    classForFocus: string;
    binds: AriaList & {
        id: string;
        class: string;
    };
};
/** Connection map. */
export type FieldComponentInclude = {
    field?: object;
};
/** Included slots. */
export interface FieldSlotsInclude extends Omit<FieldSlots, 'default'> {
}
/** Connection properties. */
export type FieldPropsInclude<Icon extends IconPropsBasic = IconPropsBasic, Field extends FieldPropsBasic = FieldPropsBasic, FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = Omit<FieldPropsBasic<Icon, FieldLabel, FieldMessage, FieldCounter, Progress>, 'disabledPrevious' | 'disabledNext' | 'to' | 'value' | 'maxlength' | 'cancelShow' | 'counter' | 'counterTemplate' | 'counterTop' | 'iconArrowLeft' | 'iconArrowRight' | 'iconPlus' | 'iconMinus' | 'iconClose'> & {
    focus?: boolean;
    selected?: boolean;
    readonly?: boolean;
    disabled?: boolean;
    align?: 'center' | 'right' | 'left';
    cancel?: 'auto' | 'always' | 'none';
    fieldAttrs?: ConstrBind<Field>;
};

// File: constructors/Field/props.d.ts
export type FieldPropsToken = {
    focus?: boolean;
    disabled?: boolean;
    selected?: boolean;
    readonly?: boolean;
    block?: boolean;
    isValue?: boolean;
    basic?: boolean;
    boxed?: boolean;
    tonal?: boolean;
    filled?: boolean;
    outlined?: boolean;
    classic?: boolean;
    arrowCarousel?: boolean;
    arrowStepper?: boolean;
    arrowAlign?: string | 'center' | 'right' | 'left';
    cancel?: string | 'auto' | 'always' | 'none';
    align?: string | 'center' | 'right' | 'left';
    width?: string | 'custom';
};
export type FieldPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = IconTrailingPropsInclude<Icon> & PrefixProps & SuffixProps & CaptionProps & FieldLabelPropsInclude<FieldLabel, FieldCounter> & FieldMessagePropsInclude<FieldMessage, FieldCounter> & ProgressPropsInclude<Progress> & EnabledProps & EventClickProps & SkeletonPropsInclude & TextCancelPropsInclude & {
    /** Disable previous arrow. */
    disabledPrevious?: boolean;
    /** Disable next arrow. */
    disabledNext?: boolean;
    /** Field ID. */
    id?: string | number;
    /** Top counter position. */
    counterTop?: boolean;
    /** Show cancel button. */
    cancelShow?: boolean;
    iconArrowLeft?: IconValue<Icon>;
    iconArrowRight?: IconValue<Icon>;
    iconPlus?: IconValue<Icon>;
    iconMinus?: IconValue<Icon>;
    iconClose?: IconValue<Icon>;
};
export type FieldProps = FieldPropsBasic & FieldPropsToken;
export declare const defaultsField: {
    arrowAlign: string;
    cancel: string;
};

// File: constructors/Field/types.d.ts
export type FieldComponents = IconComponentInclude & FieldLabelComponentInclude & FieldMessageComponentInclude & ProgressComponentInclude;
export type FieldEmits = EventClickEmits;
export interface FieldExpose {
}
export interface FieldSlots extends CaptionSlots, PrefixSlots, SuffixSlots, FieldLabelSlotsInclude {
    leading?(props: FieldControl): any;
    trailing?(props: FieldControl): any;
    default?(props: FieldControl): any;
}
export type FieldClasses = {
    main: ConstrClass;
    body: string;
    bodyInput: string;
    bodyTitle: string;
    bodyTitleLabel: string;
    bodyTitleLabelText: string;
    bodyScoreboard: string;
    bodyScoreboardLeft: string;
    bodyScoreboardRight: string;
    bodyScoreboardSpace: string;
    bodyScoreboardInput: string;
    bodyBorder: string;
    required: string;
};

// File: constructors/FieldCounter/basicTypes.d.ts
/** Connection map. */
export type FieldCounterComponentInclude = {
    fieldCounter?: object;
};
/** Included properties. */
export interface FieldCounterPropsInclude<FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic> {
    counter?: FieldCounterPropsBasic['counter'];
    counterShow?: boolean;
    counterTemplate?: FieldCounterPropsBasic['template'];
    counterId?: string;
    maxlength?: FieldCounterPropsBasic['maxlength'];
    fieldCounterAttrs?: ConstrBind<FieldCounter>;
}

// File: constructors/FieldCounter/props.d.ts
export type FieldCounterPropsBasic = TextCharacterLimitPropsInclude & TextCharacterRemainingPropsInclude & {
    /** Current value. */
    counter?: string | number;
    /** Max length. */
    maxlength?: string | number;
    /** SR announcement threshold. */
    maxlengthOnce?: string | number;
    /** Formatting template. */
    template?: string;
    /** Element ID. */
    id?: string;
};
export type FieldCounterProps = FieldCounterPropsBasic;
export declare const defaultsFieldCounter: {};

// File: constructors/FieldCounter/types.d.ts
export type FieldCounterComponents = {};
export type FieldCounterEmits = {};
export interface FieldCounterExpose {
}
export interface FieldCounterSlots {
}
export type FieldCounterClasses = {
    main: ConstrClass;
    aria: string;
};

// File: constructors/FieldLabel/basicTypes.d.ts
/** Connection map. */
export type FieldLabelComponentInclude = {
    fieldLabel?: object;
};
export interface FieldLabelSlotsInclude extends LabelAlternativeSlots {
}
/** Included properties. */
export type FieldLabelPropsInclude<FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic> = LabelProps & FieldCounterPropsInclude<FieldCounter> & {
    required?: boolean;
    fieldLabelAttrs?: ConstrBind<FieldLabel>;
};

// File: constructors/FieldLabel/props.d.ts
export type FieldLabelPropsBasic<FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = LabelProps & FieldCounterPropsInclude<FieldCounter> & ProgressPropsInclude<Progress> & SkeletonPropsInclude & {
    /** Target input ID. */
    for?: string;
    /** Required status. */
    required?: boolean;
};
export type FieldLabelProps = FieldLabelPropsBasic;
export declare const defaultsFieldLabel: {};

// File: constructors/FieldLabel/types.d.ts
export type FieldLabelComponents = FieldCounterComponentInclude & ProgressComponentInclude;
export type FieldLabelEmits = {};
export interface FieldLabelExpose {
}
export interface FieldLabelSlots extends LabelAlternativeSlots {
}
export type FieldLabelClasses = {
    main: ConstrClass;
    label: string;
    required: string;
};

// File: constructors/FieldMessage/basicTypes.d.ts
/** Message slot properties. */
export type FieldMessageSlot = {
    message?: string;
    helperMessage?: string;
    validationMessage?: string;
};
/** Connection map. */
export type FieldMessageComponentInclude = {
    fieldMessage?: object;
};
/** Included properties. */
export interface FieldMessagePropsInclude<FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic> extends FieldCounterPropsInclude<FieldCounter> {
    forceShowMessage?: boolean;
    disabled?: boolean;
    helperMessage?: string;
    validationMessage?: string;
    fieldMessageAttrs?: ConstrBind<FieldMessage>;
    helperId?: string;
    validationId?: string;
}

// File: constructors/FieldMessage/props.d.ts
export type FieldMessagePropsBasic<FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic> = FieldCounterPropsInclude<FieldCounter> & SkeletonPropsInclude & {
    forceShow?: boolean;
    disabled?: boolean;
    helperMessage?: string;
    validationMessage?: string;
    helperId?: string;
    validationId?: string;
};
export type FieldMessageProps = FieldMessagePropsBasic;
export declare const defaultsFieldMessage: {};

// File: constructors/FieldMessage/types.d.ts
export type FieldMessageComponents = FieldCounterComponentInclude;
export type FieldMessageEmits = {};
export interface FieldMessageExpose {
}
export interface FieldMessageSlots {
    helper?(props: FieldMessageSlot): any;
    validation?(props: FieldMessageSlot): any;
}
export type FieldMessageClasses = {
    main: ConstrClass;
    info: string;
    error: string;
};

// File: constructors/Grid/basicTypes.d.ts
export {};

// File: constructors/Grid/props.d.ts
export type GridProps = {};
export declare const defaultsGrid: {};

// File: constructors/Grid/types.d.ts
export type GridComponents = {};
export type GridEmits = {};
export interface GridExpose {
}
export interface GridSlots {
    default?(props: any): any;
}
export type GridClasses = {
    main: ConstrClass;
};

// File: constructors/GridItem/basicTypes.d.ts
export {};

// File: constructors/GridItem/props.d.ts
export type GridItemPropsToken = {
    base?: string | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
};
export type GridItemProps = GridItemPropsToken;
export declare const defaultsGridItem: {
    base: string;
};

// File: constructors/GridItem/types.d.ts
export type GridItemComponents = {};
export type GridItemEmits = {};
export interface GridItemExpose {
}
export interface GridItemSlots {
    default?(props: any): any;
}
export type GridItemClasses = {
    main: ConstrClass;
};

// File: constructors/Group/basicTypes.d.ts
export {};

// File: constructors/Group/props.d.ts
export type GroupPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Header extends HeaderPropsBasic = HeaderPropsBasic> = BlockPropsBasic<Icon, Header>;
export type GroupProps = GroupPropsBasic;
export declare const defaultsGroup: {
    area: string;
    tag: string;
    tagHeader: string;
};

// File: constructors/Group/types.d.ts
export type GroupComponents = BlockComponents;
export type GroupEmits = BlockEmits;
export interface GroupExpose extends BlockExpose {
}
export interface GroupSlots extends BlockSlots {
}
export type GroupClasses = {
    main: ConstrClass;
    headline: string;
    header: string;
    description: string;
    body: string;
};

// File: constructors/Header/basicTypes.d.ts
/** Connection map. */
export type HeaderComponentInclude = {
    header?: object;
};
/** Included properties. */
export type HeaderPropsInclude<Icon extends IconPropsBasic = IconPropsBasic, Header extends HeaderPropsBasic = HeaderPropsBasic> = LabelProps & CaptionProps & IconPropsInclude<Icon> & {
    tagHeader?: string;
    headerAttrs?: ConstrBind<Header>;
};
/** Included slots. */
export interface HeaderSlotsInclude extends LabelAlternativeSlots, CaptionSlots {
    trailing?(props: any): any;
}

// File: constructors/Header/props.d.ts
export type HeaderPropsToken = {
    tag?: string | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
};
export type HeaderPropsBasic<Icon extends IconPropsBasic = IconPropsBasic> = LabelProps & CaptionProps & IconPropsInclude<Icon> & AreaProps;
export type HeaderProps = HeaderPropsBasic & HeaderPropsToken;
export declare const defaultsHeader: {
    tag: string;
    area: string;
};

// File: constructors/Header/types.d.ts
export type HeaderComponents = {};
export type HeaderEmits = {};
export interface HeaderExpose {
}
export interface HeaderSlots extends LabelSlots, CaptionSlots {
    trailing?(props: any): any;
}
export type HeaderClasses = {
    main: ConstrClass;
    label: string;
    caption: string;
    icon: string;
    space: string;
};

// File: constructors/HorizontalScroll/basicTypes.d.ts
/** Control item properties. */
export type HorizontalScrollControlItem = {
    classItem: string;
    classItemSelected: string;
    binds: {
        class: string;
    };
};
/** Connection map. */
export type HorizontalScrollComponentInclude = {
    horizontalScroll?: object;
};
/** Included properties. */
export type HorizontalScrollPropsInclude<HorizontalScroll extends HorizontalScrollPropsBasic = HorizontalScrollPropsBasic> = {
    horizontalScrollFlush?: boolean;
    horizontalScrollAlign?: 'block' | 'left';
    horizontalScrollAttrs?: ConstrBind<HorizontalScroll>;
};

// File: constructors/HorizontalScroll/props.d.ts
export type HorizontalScrollPropsToken = {
    flush?: boolean;
    align?: string | 'block' | 'center' | 'left' | 'right';
};
export type HorizontalScrollPropsBasic = {
    flush?: boolean;
    tag?: string;
};
export type HorizontalScrollProps = HorizontalScrollPropsBasic & HorizontalScrollPropsToken;
export declare const defaultsHorizontalScroll: {
    flush: boolean;
    align: string;
    tag: string;
};

// File: constructors/HorizontalScroll/types.d.ts
export type HorizontalScrollComponents = {};
export type HorizontalScrollEmits = {};
export interface HorizontalScrollExpose {
    /** Scroll to selected item. */
    toSelected(): void;
}
export interface HorizontalScrollSlots {
    default?(props: any): any;
}
export type HorizontalScrollClasses = {
    main: ConstrClass;
};

// File: constructors/Icon/basicTypes.d.ts
/** Icon load event data. */
export type IconEventLoad = {
    isActive: boolean;
    iconBind: ConstrItem | undefined;
    iconActiveBind: ConstrItem | undefined;
};
/** Icon value types. */
export type IconValue<Icon extends IconPropsBasic = IconPropsBasic> = string | ConstrBind<Icon> | null;
/** Connection map. */
export type IconComponentInclude = {
    icon?: object;
};
/** Included lite properties. */
export type IconLitePropsInclude<Icon extends IconPropsBasic = IconPropsBasic> = {
    icon?: IconValue<Icon>;
};
/** Included full properties. */
export type IconPropsInclude<Icon extends IconPropsBasic = IconPropsBasic> = IconLitePropsInclude<Icon> & {
    selected?: boolean;
    iconTurn?: boolean;
    iconHide?: boolean;
    iconDir?: boolean;
    iconPalette?: boolean;
    iconAttrs?: ConstrBind<Icon>;
};
/** Included trailing icon properties. */
export type IconTrailingPropsInclude<Icon extends IconPropsBasic = IconPropsBasic> = IconPropsInclude<Icon> & {
    iconTrailing?: IconValue<Icon>;
    iconTrailingTurnOnly?: boolean;
    iconTrailingDirOnly?: boolean;
    iconTrailingPalette?: boolean;
};

// File: constructors/Icon/props.d.ts
export type IconPropsToken = {
    turn?: boolean;
    disabled?: boolean;
    hide?: boolean;
    asPalette?: boolean;
    dir?: boolean;
    overlay?: boolean;
    dynamic?: boolean;
    start?: boolean;
    end?: boolean;
    high?: boolean;
    animationType?: string | 'type1' | 'type2';
    animationShow?: boolean;
};
export type IconPropsBasic<Image extends ImagePropsBasic = ImagePropsBasic> = SkeletonPropsInclude & AriaLabelPropsInclude & EventClickProps & {
    /** Active status. */
    active?: boolean;
    /** Main icon value. */
    icon?: ImageValue<Image>;
    /** Active icon value. */
    iconActive?: ImageValue<Image>;
    /** ARIA role. */
    role?: RoleType;
    tabindex?: number | string;
};
export type IconProps = IconPropsBasic & IconPropsToken;
export declare const defaultsIcon: {
    animationType: string;
};

// File: constructors/Icon/types.d.ts
export type IconComponents = ImageComponentInclude;
export type IconEmits = ImageEmitsInclude & EventClickEmits;
export interface IconExpose extends EventClickExpose {
    /** Active state reference. */
    isActive: ComputedRef<boolean>;
}
export interface IconSlots {
    default?(props: any): any;
}
export type IconClasses = {
    main: ConstrClass;
};

// File: constructors/Image/basicTypes.d.ts
/** Image types. */
export declare enum ImageTypeValue {
    pdf = "pdf",
    file = "file",
    array = "array",
    image = "image",
    flag = "flag",
    flagCompressed = "flag-compressed",
    color = "color",
    public = "public",
    filled = "filled",
    outlined = "outlined",
    round = "round",
    sharp = "sharp",
    twoTone = "twoTone",
    material = "material",
    icon = "icon"
}
export type ImageElement = HTMLElement | undefined;
export type ImageAttrs = Record<keyof HTMLImageElement, any>;
export type ImageCoordinatorItem = [number] | [number, number] | [number, number, number] | [number, number, number, number] | Undefined;
export type ImageSize<T = number> = {
    width: T;
    height: T;
};
export type ImagePictureItem = Record<keyof HTMLSourceElement & 'key', any>;
export type ImagePictureList = ImagePictureItem[];
export type ImagePicture = Record<string, string> | ImagePictureList;
export type ImageUint8ArrayType = Uint8Array<ArrayBuffer> | ArrayBuffer;
export type ImageUint8ArrayItem = {
    item: ImageUint8ArrayType;
    type: string;
    src: string;
};
export type ImageUint8ArrayCache = ImageUint8ArrayItem[];
export type ImageItem = ImageSize & {
    image: HTMLImageElement;
    src: string;
};
export type ImageTypeItem = ImageTypeValue | Undefined;
export type ImageEventItem = ImageItem | string | undefined;
export type ImageEventType = {
    type: ImageTypeItem;
};
export type ImageEventData = ImageEventType & {
    image: ImageEventItem;
};
export type ImageValue<Image extends ImagePropsBasic = ImagePropsBasic> = string | ConstrBind<Image> | null;
/** Connection map. */
export type ImageComponentInclude = {
    image?: object;
};
export type ImageEmitsInclude = ImageEmits;
/** Connection props. */
export type ImagePropsInclude<Image extends ImagePropsBasic = ImagePropsBasic> = {
    image?: string | ConstrBind<Image>;
};

// File: constructors/Image/props.d.ts
export type ImagePropsToken = {
    turn?: boolean;
    disabled?: boolean;
    hide?: boolean;
    adaptive?: boolean;
    size?: string | 'auto' | 'contain' | 'cover';
};
export type ImagePropsBasic = {
    /** Resource value. */
    value?: string | any;
    /** Image URL. */
    url?: string;
    /** Adaptive group ID. */
    adaptiveGroup?: string;
    /** Always use adaptive logic. */
    adaptiveAlways?: boolean;
    objectWidth?: string | number;
    objectHeight?: string | number;
    /** Crop coordinates. */
    coordinator?: number[] | any;
    x?: string | number;
    y?: string | number;
    /** Use <img> tag. */
    tagImg?: boolean;
    srcset?: string | Record<string, string>;
    picture?: ImagePicture;
    alt?: string;
    lazy?: boolean;
    preloadOffset?: string;
    fetchPriority?: HTMLImageElement['fetchPriority'];
};
export type ImageProps = ImagePropsBasic & ImagePropsToken;
export declare const defaultsImage: {
    adaptiveGroup: string;
    preloadOffset: string;
};

// File: constructors/Image/types.d.ts
export type ImageComponents = {};
export type ImageEmits = {
    /** Load completion event. */
    load: [image: ImageEventData];
};
export type ImageExpose = {
    type: ComputedRef<ImageTypeItem>;
    data: ComputedRef<ImageEventItem>;
};
export interface ImageSlots {
}
export type ImageClasses = {
    main: ConstrClass;
};

// File: constructors/Input/basicTypes.d.ts
/** Connection map. */
export type InputComponentInclude = {
    input?: object;
};

// File: constructors/Input/props.d.ts
export type InputPropsBasic<Mask extends MaskPropsBasic = MaskPropsBasic, Icon extends IconPropsBasic = IconPropsBasic, Field extends FieldPropsBasic = FieldPropsBasic, FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = MaskPropsInclude<Mask> & FieldPropsInclude<Icon, Field, FieldLabel, FieldMessage, FieldCounter, Progress> & FieldInputProps<NumberOrString>;
export type InputProps = InputPropsBasic;
export declare const defaultsInput: {
    type: string;
    autocomplete: string;
    arrow: string;
    maskVisible: boolean;
};

// File: constructors/Input/types.d.ts
export type InputComponents = MaskComponentInclude & FieldComponentInclude;
export type InputEmits = FieldBasicEmits;
export interface InputExpose extends FieldBasicExpose {
}
export interface InputSlots extends FieldSlotsInclude {
}
export type InputClasses = {
    main: ConstrClass;
};

// File: constructors/List/basicTypes.d.ts
/** Connection map. */
export type ListComponentInclude = {
    list?: object;
};

// File: constructors/List/props.d.ts
export type ListPropsToken = {
    axis?: string | 'x' | 'y';
    divider?: boolean;
};
export type ListPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, ListItem extends ListItemPropsBasic = ListItemPropsBasic> = AriaRolePropsInclude & AriaMultiselectablePropsInclude & {
    /** Focus item. */
    focus?: ListSelectedItem;
    /** Selected list. */
    selected?: ListSelectedList;
    disabled?: boolean;
    lite?: boolean;
    /** Record list. */
    list?: ListRecord<ListItem>;
    liteThreshold?: number;
    highlight?: string;
    highlightLengthStart?: number;
    filterMode?: boolean;
    keyLabel?: string;
    keyValue?: string;
    max?: string | number;
    tag?: 'div' | 'button' | 'a' | 'span' | string;
    axis?: 'x' | 'y';
    divider?: boolean;
    itemAttrs?: ConstrBind<ListItem>;
    itemManagementAttrs?: ConstrBind<ListItem>;
    itemGroupAttrs?: ConstrBind<ListItem>;
    itemMenuAttrs?: ConstrBind<ListItem>;
    iconArrowDown?: IconValue<Icon>;
    iconArrowRight?: IconValue<Icon>;
    roleItem?: RoleType;
    tabindex?: string | number;
    /** Enable external control. */
    control?: boolean;
};
export type ListProps = ListPropsBasic & ListPropsToken;
export declare const defaultsList: {
    axis: string;
    keyLabel: string;
    keyValue: string;
    tag: string;
    role: string;
    tabindex: number;
};

// File: constructors/List/types.d.ts
export type ListComponents = ListItemComponentInclude & ListGroupComponentInclude & ListMenuComponentInclude;
export type ListEmits = EventClickEmits & {
    close: [];
};
export interface ListExpose {
    isSelected: ComputedRef<boolean>;
    selectedList: ComputedRef<ListList>;
    selectedNames: ComputedRef<ListNames>;
    selectedValues: ComputedRef<any[]>;
}
export type ListSlots = Record<string, (props: any) => any>;
export type ListClasses = {
    main: ConstrClass;
    space: string;
    line: string;
    subtitle: string;
    html: string;
    management: string;
    group: string;
    menu: string;
    menuGroup: string;
};

// File: constructors/ListGroup/basicTypes.d.ts
/** Connection map. */
export type ListGroupComponentInclude = {
    listGroup?: object;
};
/** Included slot props. */
export type ListGroupSlotsPropsInclude = MotionTransformControlItem & {
    open: boolean;
};

// File: constructors/ListGroup/props.d.ts
export type ListGroupPropsToken = {
    open?: boolean;
    divider?: boolean;
};
export type ListGroupPropsBasic = {
    divider?: boolean;
};
export type ListGroupProps = ListGroupPropsBasic & ListGroupPropsToken;
export declare const defaultsListGroup: {};

// File: constructors/ListGroup/types.d.ts
export type ListGroupComponents = MotionTransformComponentInclude;
export type ListGroupEmits = {};
export interface ListGroupExpose {
    open: ComputedRef<boolean>;
}
export interface ListGroupSlots {
    head?(props: ListGroupSlotsPropsInclude): any;
    list?(props: any): any;
}
export type ListGroupClasses = {
    main: ConstrClass;
    head: string;
    list: string;
};

// File: constructors/ListItem/basicTypes.d.ts
/** Connection map. */
export type ListItemComponentInclude = {
    listItem?: object;
};

// File: constructors/ListItem/props.d.ts
export type ListItemPropsToken = {
    focus?: boolean;
    open?: boolean;
    selected?: boolean;
    selectedChild?: boolean;
    readonly?: boolean;
    disabled?: boolean;
    iconTop?: boolean;
    iconAlign?: string | 'center' | 'edge';
    fill?: string | 'custom';
    divider?: boolean;
};
export type ListItemPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Badge extends BadgePropsBasic = BadgePropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = LabelHighlightProps & DescriptionProps & PrefixProps & CaptionProps & SuffixProps & IconTrailingPropsInclude<Icon> & BadgePropsInclude<Badge> & ProgressPropsInclude<Progress> & SkeletonPropsInclude & EnabledProps & EventClickProps & AriaRolePropsInclude & {
    index?: any;
    href?: string;
    tag?: 'button' | 'a' | 'span' | 'li' | 'div' | string;
    filterMode?: boolean;
    divider?: boolean;
    tabindex?: number | string;
    type?: string;
    parent?: string;
    listId?: number;
    search?: string;
};
export type ListItemProps = ListItemPropsBasic & ListItemPropsToken;
export declare const defaultsListItem: {
    iconAlign: string;
    tabindex: string;
    role: string;
};

// File: constructors/ListItem/types.d.ts
export type ListItemComponents = IconComponentInclude & BadgeComponentInclude & ProgressComponentInclude & RippleComponentInclude;
export type ListItemEmits = EventClickEmits;
export interface ListItemExpose extends EventClickExpose {
}
export interface ListItemSlots extends LabelHighlightSlots, DescriptionSlots, PrefixSlots, CaptionSlots, SuffixSlots {
    leading?(props: any): any;
    trailing?(props: any): any;
    body?(props: any): any;
}
export type ListItemClasses = {
    main: ConstrClass;
    body: string;
    context: string;
    label: string;
    highlight: string;
    prefix: string;
    caption: string;
    description: string;
    icon: string;
    trailing: string;
    badge: string;
    input: string;
};

// File: constructors/ListMenu/basicTypes.d.ts
/** Connection map. */
export type ListMenuComponentInclude = {
    listMenu?: object;
};

// File: constructors/ListMenu/props.d.ts
export type ListMenuPropsToken = {
    open?: boolean;
    axis?: string | 'x' | 'y';
    divider?: boolean;
};
export type ListMenuPropsBasic<Window extends WindowPropsBasic = WindowPropsBasic> = WindowPropsInclude<Window>;
export type ListMenuProps = ListMenuPropsBasic & ListMenuPropsToken;
export declare const defaultsListMenu: {
    autoClose: boolean;
};

// File: constructors/ListMenu/types.d.ts
export type ListMenuComponents = WindowComponentInclude;
export type ListMenuEmits = WindowEmitsInclude;
export interface ListMenuExpose extends WindowExposeInclude {
}
export interface ListMenuSlots {
    head?(props: WindowControlItem): any;
    list?(props: any): any;
}
export type ListMenuClasses = {
    main: ConstrClass;
    head: string;
    list: string;
};

// File: constructors/Mask/basicTypes.d.ts
/** Mask type options. */
export type MaskTypeItem = GeoDate | 'text' | 'number' | 'number-format' | 'currency';
export type MaskElementInput = HTMLInputElement | undefined;
export type MaskMatchItem = RegExp | string;
export type MaskFractionItem = string | boolean | number;
/** Mask special segment description. */
export type MaskSpecialItem = {
    defaultValue?: string;
    rubber?: boolean;
    transitionChar?: string | string[];
    minLength?: number;
    maxLength?: number;
    match?: MaskMatchItem;
    pattern?: FieldPatternItemOrFunction;
    view?: string;
};
export type MaskSpecialInfo = {
    index: number;
    key: number;
    char: string;
};
export type MaskSpecialList = Record<string, MaskSpecialItem>;
export type MaskSpecialProp = string | string[] | MaskSpecialList;
export type MaskViewItem = {
    className: string;
    value: string;
};
export type MaskViewList = MaskViewItem[];
export type MaskList = string | string[];
export type MaskEventData = FieldValidationItem;
/** Selection event details. */
export type MaskEventSelection = {
    target: HTMLInputElement;
    start: number;
    end: number;
    length: number;
};
/** Connection map. */
export type MaskComponentInclude = {
    mask?: object;
};
/** Connection props. */
export type MaskPropsInclude<Mask extends MaskPropsBasic = MaskPropsBasic> = {
    name?: string;
    mask?: string | ConstrBind<Mask>;
    maskVisible?: boolean;
    maskNone?: boolean;
    currency?: string;
    currencyHide?: boolean;
    fraction?: MaskFractionItem;
    maskAttrs?: ConstrBind<Mask>;
};
export declare const MASK_CHAR_DELETE = "~";
export declare const MASK_VIEW_DEFAULT = "_";

// File: constructors/Mask/props.d.ts
export type MaskPropsToken = {
    visible?: boolean;
    visiblePartly?: boolean;
    align?: string | 'center' | 'left' | 'right';
    dir?: string | 'ltr' | 'rtl';
};
export type MaskPropsBasic = {
    name?: string;
    value?: string | number;
    valueDefault?: string | number;
    currency?: string;
    currencyHide?: boolean;
    fullOnly?: boolean;
    mask?: MaskList;
    special?: MaskSpecialProp;
    match?: MaskMatchItem;
    groupSave?: boolean;
    pattern?: FieldPatternItemOrFunction;
    check?: FieldPatternItemOrFunction;
    fraction?: MaskFractionItem;
    type?: MaskTypeItem;
    view?: string;
    inputAttrs?: Partial<HTMLInputElement>;
    language?: string;
};
export type MaskProps = MaskPropsBasic & MaskPropsToken;
export declare const defaultsMask: {
    visible: boolean;
    special: string;
    match: RegExp;
    type: string;
    groupSave: boolean;
    view: string;
};

// File: constructors/Mask/types.d.ts
export type MaskComponents = {};
export type MaskEmits = {
    focus: [event: FocusEvent];
    blur: [event: FocusEvent];
    keydown: [event: KeyboardEvent];
    keyup: [event: KeyboardEvent];
    beforeinput: [event: InputEvent];
    input: [event: InputEvent, value: FieldValidationItem];
    inputLite: [value: FieldValidationItem];
    change: [event: InputEvent, value: FieldValidationItem];
    changeLite: [value: FieldValidationItem];
    paste: [event: ClipboardEvent];
    reset: [event: Event];
};
export interface MaskExpose {
    /** Raw value. */
    valueBasic: ComputedRef<string>;
    /** Formatted value. */
    value: ComputedRef<string>;
    /** Update value. */
    setValue(value: string): boolean;
    /** Clear value. */
    clear(): boolean;
}
export interface MaskSlots {
}
export type MaskClasses = {
    main: ConstrClass;
    input: string;
    character: string;
    characterItem: string;
};

// File: constructors/Menu/basicTypes.d.ts
/** Basic menu control. */
export type MenuControlBasic = ListExpose & {
    loading: Ref<boolean>;
    previous(): NumberOrStringOrBoolean | undefined;
    next(): NumberOrStringOrBoolean | undefined;
};
/** Composite control. */
export type MenuControlItem = MenuControlBasic & WindowControlItem;
/** Connection map. */
export type MenuComponentInclude = {
    menu?: object;
};
/** Expose inclusion. */
export interface MenuExposeInclude {
    open: ComputedRef<boolean>;
    setOpen(open: boolean): Promise<void>;
    toOpen: MenuExpose['toOpen'];
    toClose: MenuExpose['toClose'];
    toggle(): Promise<void>;
    menuElement: Ref<ConstrBind<MenuExpose> | undefined>;
}
/** Slot inclusion. */
export type MenuSlotInclude = {
    title?(props: MenuControlItem): any;
    footer?(props: MenuControlItem): any;
    contextTop?(props: MenuControlItem): any;
    contextBottom?(props: MenuControlItem): any;
};
/** Connection props. */
export type MenuPropsInclude<Menu extends MenuPropsBasic = MenuPropsBasic> = {
    disabled?: boolean;
    menuAttrs?: ConstrBind<Menu>;
};

// File: constructors/Menu/props.d.ts
export type MenuPropsToken = {
    hideList?: boolean;
    barsAdaptive?: string | 'showAlways';
};
export type MenuPropsBasic<List extends ListPropsBasic = ListPropsBasic, ListItem extends ListItemPropsBasic = ListItemPropsBasic, Bars extends BarsPropsBasic = BarsPropsBasic, Window extends WindowPropsBasic = WindowPropsBasic> = BarsPropsInclude<Bars> & WindowPropsInclude<Window> & ModelPropsSelected & {
    selected?: ListSelectedList;
    hideList?: boolean;
    list?: ListRecord<ListItem>;
    liteThreshold?: number;
    highlight?: string;
    highlightLengthStart?: number;
    filterMode?: boolean;
    ajax?: string | (() => NormalOrPromise<ListRecord<ListItem>>);
    request?: ApiFetch;
    cache?: boolean;
    keyLabel?: string;
    keyValue?: string;
    max?: string | number;
    tag?: ListItemProps['tag'];
    step?: string | number;
    listAttrs?: ConstrBind<List>;
    itemAttrs?: ConstrBind<ListItem>;
    roleList?: RoleType;
    roleItem?: RoleType;
    isSelectedByValue?: boolean;
    embedded?: boolean;
};
export type MenuProps = MenuPropsBasic & MenuPropsToken;
export declare const defaultsMenu: {
    liteThreshold: number;
    barsHide: boolean;
    barsBackHide: boolean;
    tag: string;
    step: number;
    autoClose: boolean;
};

// File: constructors/Menu/types.d.ts
export type MenuComponents = ListComponentInclude & BarsComponentInclude & WindowComponentInclude;
export type MenuEmits = BarsEmitsInclude & EventClickEmits & WindowEmitsInclude & ModelEmitsSelected & {
    updateValue: [value?: NumberOrStringOrBoolean];
    clickSlot: [value?: string];
};
export interface MenuExpose extends WindowExposeInclude, MenuControlBasic {
}
export type MenuSlots = ListSlots & MenuSlotInclude & {
    /** Controller slot. */
    control?(props: MenuControlItem): any;
};
export type MenuClasses = {
    main: ConstrClass;
    bars: string;
    list: string;
};

// File: constructors/Modal/basicTypes.d.ts
export {};

// File: constructors/Modal/props.d.ts
export type ModalPropsToken = {
    imagePosition?: string | 'top' | 'left';
};
export type ModalPropsBasic<Window extends WindowPropsBasic = WindowPropsBasic, Bars extends BarsPropsBasic = BarsPropsBasic, Actions extends ActionsPropsBasic = ActionsPropsBasic, Image extends ImagePropsBasic = ImagePropsBasic> = WindowPropsInclude<Window> & BarsPropsInclude<Bars> & ActionsPropsInclude<Actions> & ImagePropsInclude<Image> & {
    /** Open status. */
    open?: boolean;
};
export type ModalProps = ModalPropsBasic & ModalPropsToken;
export declare const defaultsModal: {
    imagePosition: string;
    barsBackHide: boolean;
};

// File: constructors/Modal/types.d.ts
export type ModalComponents = WindowComponentInclude & BarsComponentInclude & ActionsComponentInclude;
export type ModalEmits = WindowEmitsInclude & BarsEmitsInclude & ActionsEmitsInclude;
export interface ModalExpose extends WindowExposeInclude {
}
export interface ModalSlots extends WindowSlots {
    /** Header slot. */
    header(props: WindowControlItem): any;
}
export type ModalClasses = {
    main: ConstrClass;
    title: string;
    header: string;
    body: string;
    footer: string;
};

// File: constructors/MotionAxis/basicTypes.d.ts
/** Axis animation value. */
export type MotionAxisSelectedValue = string | undefined;
/** Status classes. */
export type MotionAxisClassStatus = {
    main: string;
    previous: string;
    preparation: string;
    active: string;
};
export type MotionAxisEmitType = 'start' | 'end';
/** Event options. */
export type MotionAxisEmitOptions = {
    type: MotionAxisEmitType;
    selected?: MotionAxisSelectedValue;
    previous?: MotionAxisSelectedValue;
    preparation?: MotionAxisSelectedValue;
    active?: MotionAxisSelectedValue;
};
/** Connection map. */
export type MotionAxisComponentInclude = {
    motionAxis?: object;
};
/** Included events. */
export type MotionAxisEmitsInclude = {
    motionAxis: [options: MotionAxisEmitOptions];
};
/** Included properties. */
export type MotionAxisPropsInclude<MotionAxis extends MotionAxisPropsBasic = MotionAxisPropsBasic> = {
    selected?: MotionAxisSelectedValue;
    motionAxisAttrs?: ConstrBind<MotionAxis>;
};

// File: constructors/MotionAxis/props.d.ts
export type MotionAxisPropsToken = {
    axis?: string | 'x' | 'y' | 'z';
    direction?: string | 'next' | 'back' | 'auto';
};
export type MotionAxisPropsBasic = ModelPropsSelected<MotionAxisSelectedValue> & {
    selected?: MotionAxisSelectedValue;
    animationHeight?: boolean;
    inDom?: boolean;
    inDomSlide?: string[];
};
export type MotionAxisProps = MotionAxisPropsBasic & MotionAxisPropsToken;
export declare const defaultsMotionAxis: {
    axis: string;
    direction: string;
};

// File: constructors/MotionAxis/types.d.ts
export type MotionAxisComponents = {};
export type MotionAxisEmits = ModelEmitsSelected<MotionAxisSelectedValue> & {
    motionAxis: [options: MotionAxisEmitOptions];
    start: [selected: MotionAxisSelectedValue];
    end: [selected: MotionAxisSelectedValue];
};
export interface MotionAxisExpose {
    back(): void;
    next(): void;
    to(selected: MotionAxisSelectedValue): void;
    top(selected: MotionAxisSelectedValue): void;
    right(selected: MotionAxisSelectedValue): void;
    bottom(selected: MotionAxisSelectedValue): void;
    left(selected: MotionAxisSelectedValue): void;
    down(selected: MotionAxisSelectedValue): void;
    up(selected: MotionAxisSelectedValue): void;
}
export type MotionAxisSlots = {
    [K in string]?: (props: any) => any;
};
export type MotionAxisClasses = {
    main: ConstrClass;
    slide: string;
};

// File: constructors/MotionTransform/basicTypes.d.ts
/** Transform event options. */
export type MotionTransformEmitOptions = {
    type: 'head' | 'body' | 'top' | 'script';
    open: boolean;
};
/** Styling classes. */
export type MotionTransformClassList = {
    show: string;
    open: string;
    window: string;
    click: string;
    none: string;
    noneGlobal: string;
    close: string;
};
/** CSS variables for layout. */
export type MotionTransformStyle = {
    contextWidth: string;
    contextHeight: string;
    headScale: string;
    top: string;
    left: string;
    headWidth: string;
    height: string;
    scale: string;
    headHeight: string;
    bodyHeight: string;
};
/** Slot properties. */
export type MotionTransformControlItem = {
    isOpen: ComputedRef<boolean>;
    isShow: ComputedRef<boolean>;
    classes: MotionTransformClassList;
    idControl: string;
    idBody: string;
    binds: AriaRoleControlPropsInclude;
};
/** Connection map. */
export type MotionTransformComponentInclude = {
    motionTransform?: object;
};
/** Included events. */
export type MotionTransformEmitsInclude = {
    transform: MotionTransformEmits['transform'];
    transformLite: MotionTransformEmits['transformLite'];
};
/** Expose inclusion. */
export interface MotionTransformExposeInclude extends MotionTransformExpose {
    motionTransformElement: Ref<ConstrBind<MotionTransformExpose> | undefined>;
}
/** Connection props. */
export interface MotionTransformPropsInclude<MotionTransform extends MotionTransformProps = MotionTransformProps> {
    open?: boolean;
    clickOpen?: boolean;
    autoClose?: boolean;
    motionTransformAttrs?: ConstrBind<MotionTransform>;
}
export declare const __MOTION_TRANSFORM_TYPE_BODY_NAME = "--sys-type-body";

// File: constructors/MotionTransform/props.d.ts
export type MotionTransformPropsToken = {
    section?: boolean;
    animationHeadPosition?: string | 'top' | 'toBottom';
    adaptive?: string | 'planeAlways';
};
export type MotionTransformPropsBasic = AriaByPropsInclude & ModelPropsOpen & {
    open?: boolean;
    inDom?: boolean;
    ignore?: HTMLElement | string;
    ignoreSelector?: string;
    clickOpen?: boolean;
    autoClose?: boolean;
    animationShow?: boolean;
    tagBody?: string;
};
export type MotionTransformProps = MotionTransformPropsBasic & MotionTransformPropsToken;
export declare const defaultsMotionTransform: {
    animationHeadPosition: string;
    clickOpen: boolean;
    autoClose: boolean;
    animationShow: boolean;
    tagBody: string;
};

// File: constructors/MotionTransform/types.d.ts
export type MotionTransformComponents = {};
export type MotionTransformEmits = ModelEmitsOpen & {
    /** Transform finished event. */
    transform: [event: Event | undefined, options: MotionTransformEmitOptions];
    /** Lite transform event. */
    transformLite: [options: MotionTransformEmitOptions];
};
export interface MotionTransformExpose {
    open: Ref<boolean>;
    isShow: ComputedRef<boolean>;
    setOpen(open: boolean): void;
    toOpen(): void;
    toClose(): void;
    toggle(): void;
}
export interface MotionTransformSlots {
    head?(props: MotionTransformControlItem): any;
    body?(props: MotionTransformControlItem): any;
}
export type MotionTransformClasses = {
    main: ConstrClass;
    context: string;
    head: string;
    body: string;
    backdrop: string;
    scrim: string;
    clickNone: string;
};

// File: constructors/Page/basicTypes.d.ts
export {};

// File: constructors/Page/props.d.ts
export type PagePropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Header extends HeaderPropsBasic = HeaderPropsBasic> = BlockPropsBasic<Icon, Header>;
export type PageProps = PagePropsBasic;
export declare const defaultsPage: {
    area: string;
    tag: string;
    tagHeader: string;
};

// File: constructors/Page/types.d.ts
export type PageComponents = BlockComponents;
export type PageEmits = BlockEmits;
export interface PageExpose extends BlockExpose {
}
export interface PageSlots extends BlockSlots {
}
export type PageClasses = {
    main: ConstrClass;
    headline: string;
    header: string;
    description: string;
    body: string;
};

// File: constructors/PageArea/basicTypes.d.ts
export {};

// File: constructors/PageArea/props.d.ts
export type PageAreaPropsBasic = BlockProps;
export type PageAreaProps = PageAreaPropsBasic;
export declare const defaultsPageArea: {};

// File: constructors/PageArea/types.d.ts
export type PageAreaComponents = {
    block: object;
    group: object;
    page: object;
    section: object;
};
export type PageAreaEmits = {};
export interface PageAreaExpose {
}
export interface PageAreaSlots extends BlockSlots {
}
export type PageAreaClasses = {
    main: ConstrClass;
};

// File: constructors/Progress/basicTypes.d.ts
/** Connection map. */
export type ProgressComponentInclude = {
    progress?: object;
};
/** Included props. */
export type ProgressPropsInclude<Progress extends ProgressPropsBasic = ProgressPropsBasic> = {
    loading?: boolean | ConstrBind<Progress>;
};

// File: constructors/Progress/props.d.ts
export type ProgressPropsToken = {
    point?: boolean;
    linear?: boolean;
    circular?: boolean;
    indeterminate?: string | 'type1' | 'type2' | 'type3';
    position?: string | 'top' | 'bottom' | 'static';
    dense?: boolean;
    inverse?: boolean;
};
export type ProgressPropsBasic = AriaLabelPropsInclude & TextLoadingPropsInclude & ClientOnlyPropsInclude & {
    visible?: boolean;
    value?: number | string;
    max?: number | string;
    linear?: boolean;
    circular?: boolean;
    point?: boolean;
    delay?: number | string;
    delayHide?: number | string;
};
export type ProgressProps = ProgressPropsBasic & ProgressPropsToken;
export declare const defaultsProgress: {
    linear: boolean;
    indeterminate: string;
    position: string;
    clientOnly: boolean;
    max: number;
    delay: number;
    delayHide: number;
};

// File: constructors/Progress/types.d.ts
export type ProgressComponents = {};
export type ProgressEmits = {};
export interface ProgressExpose {
}
export interface ProgressSlots {
}
export type ProgressClasses = {
    main: ConstrClass;
    circle: string;
    circleSub: string;
    point: string;
};

// File: constructors/Ripple/basicTypes.d.ts
/** Connection map. */
export type RippleComponentInclude = {
    ripple?: object;
};

// File: constructors/Ripple/props.d.ts
export type RipplePropsBasic = {
    disabled?: boolean;
};
export type RippleProps = RipplePropsBasic;
export declare const defaultsRipple: {};

// File: constructors/Ripple/types.d.ts
export type RippleComponents = {};
export type RippleEmits = {};
export interface RippleExpose {
}
export interface RippleSlots {
}
export type RippleClasses = {
    main: ConstrClass;
    item: string;
};

// File: constructors/Scrollbar/basicTypes.d.ts
export type ScrollbarEdgeType = 'top' | 'bottom';
/** Connection map. */
export type ScrollbarComponentInclude = {
    scrollbar?: object;
};
/** Included events. */
export type ScrollbarEmitsInclude = {
    scrollbarTop: ScrollbarEmits['top'];
    scrollbarReachTop: ScrollbarEmits['reachTop'];
    scrollbarLeaveTop: ScrollbarEmits['leaveTop'];
    scrollbarBottom: ScrollbarEmits['bottom'];
    scrollbarReachBottom: ScrollbarEmits['reachBottom'];
    scrollbarLeaveBottom: ScrollbarEmits['leaveBottom'];
    scrollbarEdge: ScrollbarEmits['edge'];
};
/** Included props. */
export type ScrollbarPropsInclude<Scrollbar extends ScrollbarPropsBasic = ScrollbarPropsBasic> = {
    scrollbarAttrs?: ConstrBind<Scrollbar>;
};

// File: constructors/Scrollbar/props.d.ts
export type ScrollbarPropsToken = {
    visible?: boolean;
    divider?: boolean;
    dividerTop?: boolean;
    dividerBottom?: boolean;
    dividerHide?: boolean;
    inverse?: boolean;
    standard?: boolean;
};
export type ScrollbarPropsBasic = {
    tag?: string;
};
export type ScrollbarProps = ScrollbarPropsBasic & ScrollbarPropsToken;
export declare const defaultsScrollbar: {
    tag: string;
};

// File: constructors/Scrollbar/types.d.ts
export type ScrollbarComponents = {};
export type ScrollbarEmits = {
    top: [isTop: boolean];
    reachTop: [];
    leaveTop: [];
    bottom: [isBottom: boolean];
    reachBottom: [];
    leaveBottom: [];
    edge: [isTop: boolean, isBottom: boolean, edge: ScrollbarEdgeType];
};
export interface ScrollbarExpose {
}
export interface ScrollbarSlots {
    default?(props: any): any;
}
export type ScrollbarClasses = {
    main: ConstrClass;
};

// File: constructors/Section/basicTypes.d.ts
export {};

// File: constructors/Section/props.d.ts
export type SectionPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Header extends HeaderPropsBasic = HeaderPropsBasic> = BlockPropsBasic<Icon, Header>;
export type SectionProps = SectionPropsBasic;
export declare const defaultsSection: {
    area: string;
    tag: string;
    tagHeader: string;
};

// File: constructors/Section/types.d.ts
export type SectionComponents = BlockComponents;
export type SectionEmits = BlockEmits;
export interface SectionExpose extends BlockExpose {
}
export interface SectionSlots extends BlockSlots {
}
export type SectionClasses = {
    main: ConstrClass;
    headline: string;
    header: string;
    description: string;
    body: string;
};

// File: constructors/Select/basicTypes.d.ts
export {};

// File: constructors/Select/props.d.ts
export type SelectPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Field extends FieldPropsBasic = FieldPropsBasic, FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Input extends InputPropsBasic = InputPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic, Menu extends MenuPropsBasic = MenuPropsBasic> = FieldPropsInclude<Icon, Field, FieldLabel, FieldMessage, FieldCounter, Progress> & FieldSelectProps & MenuPropsInclude<Menu> & {
    editValue?: boolean;
    hideList?: boolean;
    showSearch?: boolean;
    filterMode?: boolean;
    iconArrowDown?: IconValue<Icon>;
    iconSearch?: IconValue<Icon>;
    inputSearchAttrs?: ConstrBind<Input>;
};
export type SelectProps = SelectPropsBasic;
export declare const defaultsSelect: {};

// File: constructors/Select/types.d.ts
export type SelectComponents = MenuComponentInclude & FieldComponentInclude & SelectValueComponentInclude & InputComponentInclude;
export type SelectEmits = FieldBasicEmits;
export interface SelectExpose extends FieldBasicExpose, MenuExposeInclude {
}
export interface SelectSlots extends FieldSlotsInclude, MenuSlotInclude {
}
export type SelectClasses = {
    main: ConstrClass;
    input: string;
};

// File: constructors/SelectValue/basicTypes.d.ts
/** Connection map. */
export type SelectValueComponentInclude = {
    selectValue?: object;
};
/** Connection props. */
export interface SelectValuePropsInclude {
    disabled?: boolean;
    selectValueAttrs?: ConstrBind<SelectValueProps>;
}

// File: constructors/SelectValue/props.d.ts
export type SelectValuePropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Chip extends ChipPropsBasic = ChipPropsBasic> = EnabledProps & ChipPropsInclude<Chip> & {
    placeholder?: string;
    value?: ListList;
    multiple?: boolean;
    iconShow?: boolean;
    iconAttrs?: ConstrBind<Icon>;
    iconCancel?: IconValue<Icon>;
};
export type SelectValueProps = SelectValuePropsBasic;
export declare const defaultsSelectValue: {};

// File: constructors/SelectValue/types.d.ts
export type SelectValueComponents = ChipComponentInclude;
export type SelectValueEmits = EventClickEmits;
export interface SelectValueExpose {
}
export interface SelectValueSlots {
}
export type SelectValueClasses = {
    main: ConstrClass;
    item: string;
    trailing: string;
};

// File: constructors/Skeleton/basicTypes.d.ts
/** Component internal classes. */
export type SkeletonClassesList = {
    classText: string;
    classTextVariant: string;
    classBackground: string;
    classBackgroundAfter: string;
    classBackgroundBefore: string;
    classBackgroundVariant: string;
    classBorder: string;
    classBorderVariant: string;
    classNone: string;
};
/** Included props. */
export type SkeletonPropsInclude = {
    isSkeleton?: boolean;
};

// File: constructors/Skeleton/props.d.ts
export type SkeletonPropsToken = {
    active?: boolean;
};
export type SkeletonProps = SkeletonPropsToken;
export declare const defaultsSkeleton: {};

// File: constructors/Skeleton/types.d.ts
export type SkeletonComponents = {};
export type SkeletonEmits = {};
export interface SkeletonExpose {
    isActive: ComputedRef<boolean>;
}
export interface SkeletonSlots {
    default?(props: SkeletonClassesList): any;
}
export type SkeletonClasses = {
    main: ConstrClass;
};

// File: constructors/Snackbar/basicTypes.d.ts
/** Notification item data. */
export type SnackbarValue = {
    component?: any;
    data?: ConstrBind<SnackbarItemPropsBasic>;
    highPriority?: boolean;
    delay?: number;
    value?: string;
    resumableTimer?: ResumableTimer;
};
export type SnackbarList = SnackbarValue[];

// File: constructors/Snackbar/props.d.ts
export type SnackbarPropsToken = {
    full?: boolean;
    all?: boolean;
    limit?: string | '1' | '2' | '4' | '6' | '8';
    vertical?: string | 'top' | 'bottom';
    horizontal?: string | 'right' | 'left' | 'block';
    origin?: string | 'topToBottom' | 'bottomToTop' | 'rightToLeft' | 'leftToRight';
};
export type SnackbarPropsBasic = TextNotificationsPropsInclude & {
    /** Auto-close delay. */
    delay?: number;
};
export type SnackbarProps = SnackbarPropsBasic & SnackbarPropsToken;
export declare const defaultsSnackbar: {
    delay: number;
};

// File: constructors/Snackbar/types.d.ts
export type SnackbarComponents = SnackbarItemComponentInclude;
export type SnackbarEmits = {
    show: [value: string, item: SnackbarValue];
    hide: [value: string, item: SnackbarValue];
};
export interface SnackbarExpose {
    isItem: ComputedRef<boolean>;
    add(item: SnackbarValue): void;
    remove(value: string): void;
    clear(): void;
}
export interface SnackbarSlots {
}
export type SnackbarClasses = {
    main: ConstrClass;
    item: string;
    space: string;
    priority: string;
};

// File: constructors/SnackbarItem/basicTypes.d.ts
/** Connection map. */
export type SnackbarItemComponentInclude = {
    snackbarItem?: object;
};
/** Included props. */
export type SnackbarItemPropsInclude<SnackbarItemProps extends SnackbarItemPropsBasic = SnackbarItemPropsBasic> = {
    snackbarItemAttrs?: ConstrBind<SnackbarItemProps>;
};

// File: constructors/SnackbarItem/props.d.ts
export type SnackbarItemPropsToken = {
    success?: boolean;
    error?: boolean;
};
export type SnackbarItemPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Button extends ButtonPropsBasic = ButtonPropsBasic, Actions extends ActionsPropsBasic = ActionsPropsBasic> = LabelProps & DescriptionProps & IconTrailingPropsInclude<Icon> & ActionsPropsInclude<Actions> & AriaRolePropsInclude & AriaLivePropsInclude & TextClosePropsInclude & AreaProps & {
    button?: string | number | ConstrBind<Button>;
    html?: string;
    component?: any;
    componentProps?: object;
    value?: string;
    closeButton?: boolean;
    iconClose?: IconValue<Icon>;
};
export type SnackbarItemProps = SnackbarItemPropsBasic & SnackbarItemPropsToken;
export declare const defaultsSnackbarItem: {
    area: string;
    closeButton: boolean;
};

// File: constructors/SnackbarItem/types.d.ts
export type SnackbarItemComponents = IconComponentInclude & ButtonComponentInclude & ActionsComponentInclude;
export type SnackbarItemEmits = ActionsEmitsInclude & EventClickEmits & {
    close: [value: string | undefined];
};
export interface SnackbarItemExpose {
}
export interface SnackbarItemSlots extends LabelSlots, DescriptionSlots {
    body?(props: any): any;
}
export type SnackbarItemClasses = {
    main: ConstrClass;
    tool: string;
    icon: string;
    trailing: string;
    context: string;
    label: string;
    description: string;
    body: string;
    button: string;
    close: string;
    actions: string;
};

// File: constructors/TabItem/basicTypes.d.ts
/** Connection map. */
export type TabItemComponentInclude = {
    tabItem?: object;
};

// File: constructors/TabItem/props.d.ts
export type TabItemPropsToken = {
    focus?: boolean;
    open?: boolean;
    selected?: boolean;
    disabled?: boolean;
    adaptive?: string | 'iconAlways' | 'auto';
    container?: boolean;
};
export type TabItemPropsBasic<Icon extends IconPropsBasic = IconPropsBasic, Badge extends BadgePropsBasic = BadgePropsBasic> = LabelProps & IconPropsInclude<Icon> & BadgePropsInclude<Badge> & SkeletonPropsInclude & EnabledProps & EventClickProps & AriaRolePropsInclude & {
    index?: any;
    href?: string;
    tag?: 'button' | 'a' | 'span' | 'li' | 'div' | string;
};
export type TabItemProps = TabItemPropsBasic & TabItemPropsToken;
export declare const defaultsTabItem: {
    role: string;
};

// File: constructors/TabItem/types.d.ts
export type TabItemComponents = IconComponentInclude & BadgeComponentInclude & ProgressComponentInclude & RippleComponentInclude;
export type TabItemEmits = EventClickEmits;
export interface TabItemExpose extends EventClickExpose {
}
export interface TabItemSlots extends LabelSlots {
}
export type TabItemClasses = {
    main: ConstrClass;
    label: string;
    icon: string;
    badge: string;
};

// File: constructors/Tabs/basicTypes.d.ts
export {};

// File: constructors/Tabs/props.d.ts
export type TabsPropsBasic<TabItem extends TabItemPropsBasic = TabItemPropsBasic, TabsNavigation extends TabsNavigationPropsBasic = TabsNavigationPropsBasic, MotionAxis extends MotionAxisPropsBasic = MotionAxisPropsBasic> = TabsNavigationPropsInclude<TabItem, TabsNavigation> & MotionAxisPropsInclude<MotionAxis> & ModelPropsSelected<ListSelectedList>;
export type TabsProps = TabsPropsBasic;
export declare const defaultsTabs: {};

// File: constructors/Tabs/types.d.ts
export type TabsComponents = TabsNavigationComponentInclude & MotionAxisComponentInclude;
export type TabsEmits = TabsNavigationEmits & MotionAxisEmitsInclude & EventClickEmits & ModelEmitsSelected<ListSelectedList>;
export interface TabsExpose extends EventClickExpose {
}
export type TabsSlots = MotionAxisSlots;
export type TabsClasses = {
    main: ConstrClass;
    slide: string;
};

// File: constructors/TabsNavigation/basicTypes.d.ts
/** Value-to-ID map. */
export type TabsNavigationIdsList = Record<NumberOrString, string>;
/** Connection map. */
export type TabsNavigationComponentInclude = {
    tabsNavigation?: object;
};
/** Included properties. */
export type TabsNavigationPropsInclude<TabItem extends TabItemPropsBasic = TabItemPropsBasic, TabsNavigation extends TabsNavigationPropsBasic = TabsNavigationPropsBasic> = {
    tabs?: ListRecord<TabItem> | ConstrBind<TabsNavigation>;
    tabItemAttrs?: ConstrBind<TabItem>;
    tabsNavigationAttrs?: ConstrBind<TabsNavigation>;
};

// File: constructors/TabsNavigation/props.d.ts
export type TabsNavigationPropsToken = {
    divider?: boolean;
};
export type TabsNavigationPropsBasic<TabItem extends TabItemPropsBasic = TabItemPropsBasic> = HorizontalScrollPropsInclude & ModelPropsSelected<ListSelectedList> & {
    selected?: ListSelectedList;
    list?: ListRecord<TabItem>;
    tag?: TabItem['tag'];
    keyLabel?: string;
    keyValue?: string;
    itemAttrs?: ConstrBind<TabItem>;
};
export type TabsNavigationProps = TabsNavigationPropsBasic & TabsNavigationPropsToken;
export declare const defaultsTabsNavigation: {
    horizontalScrollFlush: boolean;
    horizontalScrollAlign: string;
};

// File: constructors/TabsNavigation/types.d.ts
export type TabsNavigationComponents = HorizontalScrollComponentInclude & TabItemComponentInclude;
export type TabsNavigationEmits = EventClickEmits & ModelEmitsSelected<ListSelectedList>;
export interface TabsNavigationExpose {
    ids: ComputedRef<TabsNavigationIdsList>;
}
export interface TabsNavigationSlots {
    leading?(props: any): any;
    trailing?(props: any): any;
}
export type TabsNavigationClasses = {
    main: ConstrClass;
};

// File: constructors/Textarea/basicTypes.d.ts
export {};

// File: constructors/Textarea/props.d.ts
export type TextareaPropsBasic<TextareaAutosize extends TextareaAutosizePropsBasic = TextareaAutosizePropsBasic, Icon extends IconPropsBasic = IconPropsBasic, Field extends FieldPropsBasic = FieldPropsBasic, FieldLabel extends FieldLabelPropsBasic = FieldLabelPropsBasic, FieldMessage extends FieldMessagePropsBasic = FieldMessagePropsBasic, FieldCounter extends FieldCounterPropsBasic = FieldCounterPropsBasic, Progress extends ProgressPropsBasic = ProgressPropsBasic> = TextareaAutosizePropsInclude<TextareaAutosize> & FieldPropsInclude<Icon, Field, FieldLabel, FieldMessage, FieldCounter, Progress> & FieldTextareaProps<string>;
export type TextareaProps = TextareaPropsBasic;
export declare const defaultsTextarea: {
    cancel: string;
    autosize: boolean;
};

// File: constructors/Textarea/types.d.ts
export type TextareaComponents = FieldComponentInclude & TextareaAutosizeComponentInclude;
export type TextareaEmits = FieldBasicEmits;
export interface TextareaExpose extends FieldBasicExpose {
}
export interface TextareaSlots extends FieldSlotsInclude {
}
export type TextareaClasses = {
    main: ConstrClass;
};

// File: constructors/TextareaAutosize/basicTypes.d.ts
/** Connection map. */
export type TextareaAutosizeComponentInclude = {
    textareaAutosize?: object;
};
/** Connection properties. */
export type TextareaAutosizePropsInclude<TextareaAutosize extends TextareaAutosizePropsBasic = TextareaAutosizePropsBasic> = {
    textareaAttrs?: ConstrBind<TextareaAutosize>;
    autosize?: boolean;
};

// File: constructors/TextareaAutosize/props.d.ts
export type TextareaAutosizePropsToken = {
    autosize?: boolean;
};
export type TextareaAutosizePropsBasic = {
    value?: string;
    inputAttrs?: Record<string, any>;
};
export type TextareaAutosizeProps = TextareaAutosizePropsBasic & TextareaAutosizePropsToken;
export declare const defaultsTextareaAutosize: {
    autosize: boolean;
};

// File: constructors/TextareaAutosize/types.d.ts
export type TextareaAutosizeComponents = {};
export type TextareaAutosizeEmits = {
    input: [event: InputEvent];
};
export interface TextareaAutosizeExpose {
    value: Ref<string>;
}
export interface TextareaAutosizeSlots {
}
export type TextareaAutosizeClasses = {
    main: ConstrClass;
    clone: string;
};

// File: constructors/Tooltip/basicTypes.d.ts
/** Control element bindings. */
export type TooltipControlBinds = AriaList & {
    class: string;
    onclick: () => void;
    onmouseover: (event: MouseEvent) => void;
    onmouseout: (event: MouseEvent) => void;
};
/** Control instance data. */
export type TooltipControl = TooltipControlBinds & {
    open: Ref<boolean>;
    binds: TooltipControlBinds;
};
/** Connection map. */
export type TooltipComponentInclude = {
    tooltip?: object;
};
/** Connection properties. */
export type TooltipPropsInclude<Tooltip extends TooltipProps = TooltipProps> = {
    tooltipAttrs?: ConstrBind<Tooltip>;
};

// File: constructors/Tooltip/props.d.ts
export type TooltipPropsToken = {
    interactive?: boolean;
    embedded?: boolean;
};
export type TooltipPropsBasic<Arrow extends ArrowProps = ArrowProps> = LabelProps & DescriptionProps & ArrowPropsInclude<Arrow> & {
    open?: boolean;
    disabled?: boolean;
    inDom?: boolean;
    top?: boolean;
    indent?: number;
    delay?: number;
    delayHide?: number;
    embedded?: boolean;
};
export type TooltipProps = TooltipPropsBasic & TooltipPropsToken;
export declare const defaultsTooltip: {
    interactive: boolean;
    indent: number;
    delay: number;
    delayHide: number;
};

// File: constructors/Tooltip/types.d.ts
export type TooltipComponents = ArrowComponentInclude;
export type TooltipEmits = {
    tooltip: [open: boolean];
};
export interface TooltipExpose {
    toggle(open: boolean, flash?: boolean): Promise<void>;
}
export interface TooltipSlots extends LabelSlots, DescriptionSlots {
    control?(props: TooltipControl): any;
    body?(): any;
}
export type TooltipClasses = {
    main: ConstrClass;
    label: string;
    description: string;
    body: string;
};

// File: constructors/Window/basicTypes.d.ts
/** Window lifecycle status. */
export declare enum WindowStatusItem {
    display = "display",
    preparation = "preparation",
    flash = "flash",
    open = "open",
    hide = "hide",
    close = "close"
}
/** Behavior control items. */
export declare enum WindowStatusControlItem {
    block = "block",
    blockChildren = "blockChildren",
    blockOther = "blockOther",
    close = "close",
    static = "static",
    controlStatic = "controlStatic",
    controlOpenOnly = "controlOpenOnly",
    controlActive = "controlActive",
    persistent = "persistent"
}
/** Event options. */
export type WindowEmitOptions = {
    id: string;
    element: HTMLDivElement;
    control: HTMLElement;
    open: boolean;
};
/** UI structure classes. */
export type WindowClassesList = {
    block: string;
    blockChildren: string;
    blockOther: string;
    close: string;
    static: string;
    control: string;
    controlId: string;
    controlStatic: string;
    controlOpenOnly: string;
    controlActive: string;
    persistent: string;
};
export type WindowEventClick = (event: MouseEvent & TouchEvent | KeyboardEvent) => Promise<void>;
export type WindowControlBasic = {
    classesWindow: WindowClassesList;
};
/** Control element properties. */
export type WindowControlItem = WindowControlBasic & {
    class: string;
    open: Ref<boolean>;
    onclick: WindowEventClick;
    onKeydown: WindowEventClick;
    oncontextmenu: WindowEventClick;
    binds: AriaList & {
        class: string;
        onclick: WindowEventClick;
        onKeydown: WindowEventClick;
        oncontextmenu: WindowEventClick;
    };
};
/** Connection map. */
export type WindowComponentInclude = {
    window?: object;
};
/** Included events. */
export type WindowEmitsInclude = {
    window: [options: WindowEmitOptions];
};
/** Expose inclusion. */
export interface WindowExposeInclude {
    id: ComputedRef<string | undefined>;
    open: ComputedRef<boolean>;
    control: ComputedRef<WindowControlItem | undefined>;
    setOpen: WindowExpose['setOpen'];
    toOpen: WindowExpose['toOpen'];
    toClose: WindowExpose['toClose'];
    toggle: WindowExpose['toggle'];
    windowElement: Ref<ConstrBind<WindowExpose> | undefined>;
}
/** Connection props. */
export type WindowPropsInclude<Window extends WindowPropsBasic = WindowPropsBasic> = {
    disabled?: boolean;
    autoClose?: boolean;
    windowAttrs?: ConstrBind<Window>;
};
export declare const __WINDOW_TYPE_BODY_NAME = "--sys-type-body";

// File: constructors/Window/props.d.ts
export type WindowPropsToken = {
    width?: string | 'auto' | 'max' | 'custom';
    height?: string | 'auto' | 'max' | 'custom';
    hide?: boolean;
    axis?: string | 'x' | 'y' | 'on';
    imagePosition?: string | 'top' | 'left';
    dense?: boolean;
    alignment?: string | 'center' | 'top' | 'topRight' | 'topLeft' | 'topFull' | 'right' | 'rightFull' | 'bottom' | 'bottomRight' | 'bottomLeft' | 'bottomFull' | 'left' | 'leftFull';
    origin?: string | 'center' | 'top' | 'right' | 'bottom' | 'left' | 'topToBottom' | 'rightToLeft' | 'bottomToTop' | 'leftToRight';
    adaptive?: string | 'menu' | 'menuWindow' | 'modal' | 'modalDynamic' | 'actionSheetRight' | 'actionSheetBottom' | 'static';
    fullscreen?: boolean;
    overscroll?: boolean;
    closeButton?: boolean;
    closeMobileHide?: boolean;
    widthMatch?: boolean;
};
export type WindowPropsBasic<Scrollbar extends ScrollbarPropsBasic = ScrollbarPropsBasic, Icon extends IconPropsBasic = IconPropsBasic, Image extends ImagePropsBasic = ImagePropsBasic> = ScrollbarPropsInclude<Scrollbar> & ImagePropsInclude<Image> & AriaRoleByPropsInclude & AriaHaspopupPropsInclude & TextClosePropsInclude & ModelPropsOpen & {
    open?: boolean;
    disabled?: boolean;
    preparation?(): NormalOrPromise<void>;
    beforeOpening?(): NormalOrPromise<boolean>;
    opening?(): NormalOrPromise<boolean>;
    beforeClosing?(): NormalOrPromise<boolean>;
    closing?(): NormalOrPromise<boolean>;
    contextmenu?: boolean;
    staticMode?: boolean;
    overElement?: ElementOrString<HTMLElement>;
    autoClose?: boolean;
    persistent?: boolean;
    flash?: boolean;
    inDom?: boolean;
    indent?: number;
    divider?: boolean;
    closeButton?: boolean;
    iconClose?: IconValue<Icon>;
    inert?: boolean;
    autoTabIndex?: boolean;
    closeOnEsc?: boolean;
    openOnArrowDown?: boolean;
    embedded?: boolean;
};
export type WindowProps = WindowPropsBasic & WindowPropsToken;
export declare const defaultsWindow: {
    axis: string;
    imagePosition: string;
    overscroll: boolean;
    indent: number;
    ariaHaspopup: string;
    role: string;
    inert: boolean;
    autoTabIndex: boolean;
    closeOnEsc: boolean;
};

// File: constructors/Window/types.d.ts
export type WindowComponents = ScrollbarComponentInclude & ButtonComponentInclude & ImageComponentInclude;
export type WindowEmits = ScrollbarEmitsInclude & ImageEmitsInclude & ModelEmitsOpen & {
    window: [options: WindowEmitOptions];
};
export interface WindowExpose {
    id: string;
    open: Ref<boolean>;
    control: ComputedRef<WindowControlItem>;
    setOpen(open: boolean): Promise<void>;
    toOpen(): Promise<void>;
    toClose(): Promise<void>;
    toggle(): Promise<void>;
}
export interface WindowSlots {
    control?(props: WindowControlItem): any;
    title?(props: WindowControlItem): any;
    footer?(props: WindowControlItem): any;
    default?(props: WindowControlItem): any;
}
export type WindowClasses = {
    main: ConstrClass;
    body: string;
    bodyGroup: string;
    bodyContext: string;
    control: string;
    image: string;
    close: string;
    teleport: string;
};

// File: functions/getAreaValue.d.ts
/** Returns the area value. */
export declare function getAreaValue(): string | undefined;

// File: functions/getClassTagAStatic.d.ts
/** Generates CSS class for tag 'a' without static styles. */
export declare const getClassTagAStatic: (design: string) => string;

// File: functions/setAreaValue.d.ts
/** Changes the area value. */
export declare function setAreaValue(value: string | Ref<string>): void;

// File: library/accordion.d.ts
export * from '../constructors/Accordion/index';

// File: library/actionSheet.d.ts
export * from '../constructors/ActionSheet/index';

// File: library/actions.d.ts
export * from '../constructors/Actions/index';

// File: library/anchor.d.ts
export * from '../constructors/Anchor/index';

// File: library/area.d.ts
export * from '../constructors/Area/index';

// File: library/arrow.d.ts
export * from '../constructors/Arrow/index';

// File: library/badge.d.ts
export * from '../constructors/Badge/index';

// File: library/bars.d.ts
export * from '../constructors/Bars/index';

// File: library/block.d.ts
export * from '../constructors/Block/index';

// File: library/button.d.ts
export * from '../constructors/Button/index';

// File: library/cell.d.ts
export * from '../constructors/Cell/index';

// File: library/checkbox.d.ts
export * from '../constructors/Checkbox/index';

// File: library/chip.d.ts
export * from '../constructors/Chip/index';

// File: library/chipGroup.d.ts
export * from '../constructors/ChipGroup/index';

// File: library/clientOnly.d.ts
export * from '../constructors/ClientOnly/index';

// File: library/container.d.ts
export * from '../constructors/Container/index';

// File: library/dialog.d.ts
export * from '../constructors/Dialog/index';

// File: library/dummy.d.ts
export * from '../constructors/Dummy/index';

// File: library/field.d.ts
export * from '../constructors/Field/index';

// File: library/fieldCounter.d.ts
export * from '../constructors/FieldCounter/index';

// File: library/fieldLabel.d.ts
export * from '../constructors/FieldLabel/index';

// File: library/fieldMessage.d.ts
export * from '../constructors/FieldMessage/index';

// File: library/grid.d.ts
export * from '../constructors/Grid/index';

// File: library/gridItem.d.ts
export * from '../constructors/GridItem/index';

// File: library/group.d.ts
export * from '../constructors/Group/index';

// File: library/header.d.ts
export * from '../constructors/Header/index';

// File: library/horizontalScroll.d.ts
export * from '../constructors/HorizontalScroll/index';

// File: library/icon.d.ts
export * from '../constructors/Icon/index';

// File: library/image.d.ts
export * from '../constructors/Image/index';

// File: library/input.d.ts
export * from '../constructors/Input/index';

// File: library/list.d.ts
export * from '../constructors/List/index';

// File: library/listGroup.d.ts
export * from '../constructors/ListGroup/index';

// File: library/listItem.d.ts
export * from '../constructors/ListItem/index';

// File: library/listMenu.d.ts
export * from '../constructors/ListMenu/index';

// File: library/mask.d.ts
export * from '../constructors/Mask/index';

// File: library/menu.d.ts
export * from '../constructors/Menu/index';

// File: library/modal.d.ts
export * from '../constructors/Modal/index';

// File: library/motionAxis.d.ts
export * from '../constructors/MotionAxis/index';

// File: library/motionTransform.d.ts
export * from '../constructors/MotionTransform/index';

// File: library/page.d.ts
export * from '../constructors/Page/index';

// File: library/pageArea.d.ts
export * from '../constructors/PageArea/index';

// File: library/plugin.d.ts
export * from '../classes/Plugin/Plugin';
export * from '../types/pluginTypes';

// File: library/progress.d.ts
export * from '../constructors/Progress/index';

// File: library/ripple.d.ts
export * from '../constructors/Ripple/index';

// File: library/scrollbar.d.ts
export * from '../constructors/Scrollbar/index';

// File: library/section.d.ts
export * from '../constructors/Section/index';

// File: library/select.d.ts
export * from '../constructors/Select/index';

// File: library/selectValue.d.ts
export * from '../constructors/SelectValue/index';

// File: library/skeleton.d.ts
export * from '../constructors/Skeleton/index';

// File: library/snackbar.d.ts
export * from '../constructors/Snackbar/index';

// File: library/snackbarItem.d.ts
export * from '../constructors/SnackbarItem/index';

// File: library/tabItem.d.ts
export * from '../constructors/TabItem/index';

// File: library/tabs.d.ts
export * from '../constructors/Tabs/index';

// File: library/tabsNavigation.d.ts
export * from '../constructors/TabsNavigation/index';

// File: library/textarea.d.ts
export * from '../constructors/Textarea/index';

// File: library/textareaAutosize.d.ts
export * from '../constructors/TextareaAutosize/index';

// File: library/tooltip.d.ts
export * from '../constructors/Tooltip/index';

// File: library/window.d.ts
export * from '../constructors/Window/index';

// File: library.d.ts
export * from './classes/AreaInclude';
export * from './classes/AriaStaticInclude';
export * from './classes/CaptionInclude';
export * from './classes/ClientOnlyInclude';
export * from './classes/DescriptionInclude';
export * from './classes/EnabledInclude';
export * from './classes/EventClickInclude';
export * from './classes/Field/FieldArrowInclude';
export * from './classes/Field/FieldAttributesInclude';
export * from './classes/Field/FieldChangeInclude';
export * from './classes/Field/FieldCodeInclude';
export * from './classes/Field/FieldElementInclude';
export * from './classes/Field/FieldEventInclude';
export * from './classes/Field/FieldInputCheckInclude';
export * from './classes/Field/FieldInputModeInclude';
export * from './classes/Field/FieldMatchInclude';
export * from './classes/Field/FieldPatternInclude';
export * from './classes/Field/FieldTypeInclude';
export * from './classes/Field/FieldValidationInclude';
export * from './classes/Field/FieldValueInclude';
export * from './classes/Field/FieldVisibilityInclude';
export * from './classes/LabelHighlightInclude';
export * from './classes/LabelInclude';
export * from './classes/LabelNumberInclude';
export * from './classes/ModelInclude';
export * from './classes/ModelValueInclude';
export * from './classes/Plugin/Plugin';
export * from './classes/Plugin/PluginCode';
export * from './classes/Plugin/PluginComponents';
export * from './classes/Plugin/PluginData';
export * from './classes/Plugin/PluginImport';
export * from './classes/Plugin/PluginStyle';
export * from './classes/Plugin/PluginTool';
export * from './classes/PrefixInclude';
export * from './classes/ScrollToXInclude';
export * from './classes/SuffixInclude';
export * from './classes/TabIndexInclude';
export * from './classes/TextInclude';
export * from './classes/TouchEventInclude';
export * from './functions/getAreaValue';
export * from './functions/getClassTagAStatic';
export * from './functions/setAreaValue';
export * from './types/areaTypes';
export * from './types/ariaTypes';
export * from './types/captionTypes';
export * from './types/clientOnlyTypes';
export * from './types/descriptionTypes';
export * from './types/enabledTypes';
export * from './types/errorTypes';
export * from './types/eventClickTypes';
export * from './types/fieldTypes';
export * from './types/labelTypes';
export * from './types/modelTypes';
export * from './types/pluginTypes';
export * from './types/prefixTypes';
export * from './types/roleTypes';
export * from './types/suffixTypes';
export * from './types/textTypes';
export * from './types/touchEventTypes';

// File: media/styleModification.d.ts
/** List of style modifications. */
export declare const STYLE_MODIFICATION: string[];

// File: types/areaTypes.d.ts
/** Area default property. */
export type AreaProps = {
    /** Default value. */
    area?: string;
};
/** Property name. */
export declare const AREA_PROP_NAME = "UI_AREA_VALUE";

// File: types/ariaTypes.d.ts
/** ARIA state. */
export type AriaTrueOrFalse = 'true' | 'false' | boolean;
/** ARIA attributes list. */
export type AriaList = {
    'aria-activedescendant'?: string;
    'aria-atomic'?: AriaTrueOrFalse;
    'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both';
    'aria-busy'?: AriaTrueOrFalse;
    'aria-checked'?: AriaTrueOrFalse | 'mixed';
    'aria-colcount'?: number;
    'aria-colindex'?: number;
    'aria-colspan'?: number;
    'aria-controls'?: string;
    'aria-current'?: AriaTrueOrFalse | 'page' | 'step' | 'location' | 'date' | 'time';
    'aria-describedby'?: string;
    'aria-details'?: string;
    'aria-disabled'?: AriaTrueOrFalse;
    'aria-errormessage'?: string;
    'aria-expanded'?: AriaTrueOrFalse;
    'aria-flowto'?: string;
    'aria-grabbed'?: AriaTrueOrFalse;
    'aria-haspopup'?: AriaTrueOrFalse | 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid';
    'aria-hidden'?: AriaTrueOrFalse;
    'aria-invalid'?: AriaTrueOrFalse | 'grammar' | 'spelling';
    'aria-keyshortcuts'?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-level'?: number;
    'aria-live'?: 'off' | 'polite' | 'assertive';
    'aria-modal'?: AriaTrueOrFalse;
    'aria-multiline'?: AriaTrueOrFalse;
    'aria-multiselectable'?: AriaTrueOrFalse;
    'aria-orientation'?: 'horizontal' | 'vertical' | 'undefined';
    'aria-owns'?: string;
    'aria-placeholder'?: string;
    'aria-posinset'?: number;
    'aria-pressed'?: AriaTrueOrFalse | 'mixed';
    'aria-readonly'?: AriaTrueOrFalse;
    'aria-relevant'?: 'additions' | 'removals' | 'text' | 'all' | string;
    'aria-required'?: AriaTrueOrFalse;
    'aria-roledescription'?: string;
    'aria-rowcount'?: number;
    'aria-rowindex'?: number;
    'aria-rowspan'?: number;
    'aria-selected'?: AriaTrueOrFalse;
    'aria-setsize'?: number;
    'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other';
    'aria-valuemax'?: string | number;
    'aria-valuemin'?: string | number;
    'aria-valuenow'?: string | number;
    'aria-valuetext'?: string;
    'id'?: string;
    'role'?: RoleType;
    'tabindex'?: NumberOrString;
};
export type AriaAtomicPropsInclude = {
    ariaAtomic?: AriaList['aria-atomic'];
};
export type AriaByPropsInclude = {
    ariaLabelledby?: string;
    ariaDescribedby?: string;
};
export type AriaDescriptionPropsInclude = {
    ariaDescription?: string;
};
export type AriaHaspopupPropsInclude = {
    ariaHaspopup?: AriaList['aria-haspopup'];
};
export type AriaLabelPropsInclude = {
    ariaLabel?: string;
};
export type AriaLivePropsInclude = {
    ariaLive?: AriaList['aria-live'];
};
export type AriaMultiselectablePropsInclude = {
    ariaMultiselectable?: boolean;
};
export type AriaRoleByPropsInclude = AriaRolePropsInclude & AriaByPropsInclude;
export type AriaRoleControlPropsInclude = AriaRolePropsInclude & AriaHaspopupPropsInclude & {
    id?: string;
    ariaControls?: string;
    ariaHaspopup?: AriaList['aria-haspopup'];
    ariaExpanded?: string;
};
export type AriaRolePropsInclude = {
    role?: RoleType;
};

// File: types/captionTypes.d.ts
/** Caption slots. */
export interface CaptionSlots {
    caption?(props: any): any;
}
/** Caption properties. */
export type CaptionProps = {
    caption?: string | number;
    captionDecorative?: boolean;
};

// File: types/clientOnlyTypes.d.ts
export type ClientOnlyPropsInclude = {
    clientOnly?: boolean;
};

// File: types/descriptionTypes.d.ts
/** Description slots. */
export interface DescriptionSlots {
    description?(props: any): any;
}
/** Description properties. */
export type DescriptionProps = {
    description?: string | number;
    descriptionId?: string;
};

// File: types/enabledTypes.d.ts
/** Enabled state properties. */
export type EnabledProps = {
    readonly?: boolean;
    disabled?: boolean;
};

// File: types/errorTypes.d.ts
export declare const CONSTRUCTOR_ERROR_GROUP = "constructor";

// File: types/eventClickTypes.d.ts
/** Click event data. */
export type EventClickValue = {
    type: string;
    value: any;
    detail: Record<string, any> | undefined;
};
/** Click events. */
export type EventClickEmits = {
    click: [event: MouseEvent, value: EventClickValue];
    clickLite: [value: EventClickValue];
};
export interface EventClickExpose {
    value?: Ref<EventClickValue['value']>;
    detail?: Ref<EventClickValue['detail']>;
}
/** Click properties. */
export type EventClickProps = {
    to?: string | RouteLocationRaw;
    href?: string;
    value?: EventClickValue['value'];
    detail?: EventClickValue['detail'];
};

// File: types/fieldTypes.d.ts
/** Supported types. */
export type FieldType = 'text' | 'search' | 'number' | 'number-format' | 'currency' | 'email' | 'password' | 'datetime' | 'date' | 'year-month' | 'time' | 'hour-minute' | 'tel' | 'url' | 'checkbox' | 'radio';
export type FieldElementDom = HTMLInputElement | HTMLTextAreaElement;
export type FieldElementInput = FieldElementDom | HTMLElement | Record<string, any> | undefined;
export type FieldValidityCodeItem = {
    [K in keyof ValidityState]?: string;
};
export type FieldValidityCode = string | FieldValidityCodeItem;
/** Mask metadata. */
export type FieldMaskItem = {
    group: string;
    value: string;
    maxLength: number;
    full: boolean;
    end: boolean;
    chars: string[];
};
export type FieldMasks = Record<string, FieldMaskItem>;
export type FieldPatternElement = Partial<HTMLInputElement>;
export type FieldPatternItem = string | FieldPatternElement;
export type FieldPatternItemOrFunction = FieldPatternItem | ((item: FieldMasks) => FieldPatternItem);
export type FieldPatternList = Record<string, FieldPatternItemOrFunction>;
/** Field match config. */
export type FieldMatchItem = {
    name?: string | HTMLInputElement;
    validationMessage?: string;
};
export type FieldMatch = string | HTMLInputElement | FieldMatchItem;
export type FieldCheckMain = {
    group?: string;
    input?: FieldElementDom;
    pattern?: FieldPatternItemOrFunction;
};
export type FieldCheckItem<Value = any> = FieldCheckMain & {
    check(value: Value): FieldValidationItem<Value>;
};
export type FieldCheckList = Record<string, FieldCheckItem>;
/** Validation result. */
export type FieldValidationItem<Value = any> = FieldCheckMain & {
    type?: string;
    status?: boolean;
    required?: boolean;
    isFull?: boolean;
    validationMessage?: string;
    validity?: ValidityState;
    validityMessage?: string;
    value: Value;
    valueInput?: Value;
    detail?: Record<string, any>;
};
/** Generic field events. */
export type FieldBasicEmits<T = any> = ModelEmits<T> & {
    input: [event: InputEvent | Event, value: FieldValidationItem<T>];
    inputLite: [value: FieldValidationItem<T>];
    change: [event: InputEvent | Event, value: FieldValidationItem<T>];
    changeLite: [value: FieldValidationItem<T>];
};
export type FieldBasicExpose<T = string> = {
    value: ShallowRef<T | undefined>;
    checkValidity: () => boolean;
    validationMessage: ComputedRef<string>;
};
/** Value handling properties. */
export type FieldValueProps<Value = any> = ModelProps<Value> & {
    placeholder?: string;
    multiple?: boolean;
    maxlength?: NumberOrString;
    value?: Value;
    detail?: Record<string, any> | undefined;
};
/** Basic element properties. */
export type FieldBasicProps<Value = any> = Omit<FieldValueProps<Value>, 'multiple' | 'maxlength'> & {
    type?: FieldType;
    name?: string;
    id?: string | number;
    required?: boolean;
    readonly?: boolean;
    disabled?: boolean;
    autofocus?: boolean;
    tabindex?: number;
    form?: string;
    validationCode?: FieldValidityCode;
    validationMessage?: string;
    match?: FieldMatch;
    inputAttrs?: Record<string, any>;
};
export type FieldStepProps = {
    step?: NumberOrString;
    min?: NumberOrString;
    max?: NumberOrString;
};
export type FieldArrowProps = {
    arrow?: 'auto' | 'carousel' | 'stepper' | 'none';
    arrowStep?: NumberOrString;
    arrowAlign?: 'center' | 'right' | 'left';
};
export type FieldLengthProps = {
    minlength?: NumberOrString;
    maxlength?: NumberOrString;
};
export type FieldPatternProps = {
    pattern?: string;
};
export type FieldUxProps = {
    autocomplete?: string;
    autocapitalize?: 'off' | 'none' | 'sentences' | 'words' | 'characters' | string;
    inputMode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url' | string;
    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send' | string;
    spellcheck?: boolean | 'true' | 'false';
    autocorrect?: 'on' | 'off' | string;
};
export type FieldInputProps<Value = any> = FieldBasicProps<Value> & FieldStepProps & FieldArrowProps & FieldLengthProps & FieldPatternProps & FieldUxProps & {
    list?: string;
    iconVisibility?: string;
    iconVisibilityOff?: string;
};
export type FieldInputFileProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & FieldLengthProps & FieldUxProps & {
    multiple?: boolean;
    accept?: string;
    capture?: string | boolean;
};
export type FieldInputCheckProps<Value = boolean> = Omit<FieldBasicProps<Value>, 'type'> & FieldUxProps & {
    valueVariant?: NumberOrStringOrBoolean;
    valueVariantHide?: NumberOrStringOrBoolean;
    indeterminate?: boolean;
};
export type FieldTextareaProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & FieldLengthProps & FieldUxProps & {
    rows?: NumberOrString;
    cols?: NumberOrString;
    wrap?: 'soft' | 'hard' | 'off' | string;
    fieldSizing?: 'content' | 'fixed' | string;
};
export type FieldSelectProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & Omit<FieldStepProps, 'min' | 'step'> & FieldArrowProps & FieldUxProps & {
    option?: ListRecord;
    multiple?: boolean;
};
export type FieldAllProps<Value = any> = FieldInputProps<Value> & FieldInputFileProps<Value> & FieldInputCheckProps<Value> & FieldTextareaProps<Value> & FieldSelectProps<Value>;

// File: types/labelTypes.d.ts
/** Label slots. */
export interface LabelSlots {
    default?(props: any): any;
}
export interface LabelAlternativeSlots {
    label?(props: any): any;
}
export interface LabelNumberSlots extends LabelSlots {}
export interface LabelHighlightSlots extends LabelSlots {}
/** Label properties. */
export type LabelProps = {
    label?: NumberOrString;
    labelId?: string;
};
/** Numeric label properties. */
export type LabelNumberProps = LabelProps & {
    labelMax?: NumberOrString;
    formatting?: boolean;
};
/** Highlighted label properties. */
export type LabelHighlightProps = LabelProps & {
    highlight?: string;
    highlightLengthStart?: number;
    value?: any;
};

// File: types/modelTypes.d.ts
/** Model events. */
export type ModelEmits<Value = string> = {
    'update:value': [value: Value];
    'update:modelValue': [value: Value];
};
/** Open state events. */
export type ModelEmitsOpen<Value = boolean> = {
    'update:open': [value: Value];
    'update:modelOpen': [value: Value];
};
/** Selection events. */
export type ModelEmitsSelected<Value = string> = {
    'update:selected': [value: Value];
    'update:modelSelected': [value: Value];
};
/** Model value props. */
export type ModelProps<Value = string> = {
    'modelValue'?: Value;
    'onUpdate:value'?: (value: Value) => void;
    'onUpdate:modelValue'?: (value: Value) => void;
};
/** Open state props. */
export type ModelPropsOpen<Value = boolean> = {
    'modelOpen'?: Value;
    'onUpdate:open'?: (value: Value) => void;
    'onUpdate:modelOpen'?: (value: Value) => void;
};
/** Selection props. */
export type ModelPropsSelected<Value = string> = {
    'modelSelected'?: Value;
    'onUpdate:selected'?: (value: Value) => void;
    'onUpdate:modelSelected'?: (value: Value) => void;
};

// File: types/pluginTypes.d.ts
/** Plugin component item. */
export type PluginComponentItem = {
    name: string;
    reg: RegExp;
};
export type PluginComponentList = Record<string, PluginComponentItem>;
export type PluginComponentImports = PluginComponentItem[];
/** Plugin configuration. */
export type PluginOptions = {
    style?: boolean;
    component?: boolean;
    viteOptions?: VitePlugin;
};

// File: types/prefixTypes.d.ts
/** Prefix slots. */
export interface PrefixSlots {
    prefix?(props: any): any;
}
/** Prefix properties. */
export type PrefixProps = {
    prefix?: string | number;
    prefixId?: string;
};

// File: types/roleTypes.d.ts
/** ARIA roles. */
export type RoleType = string | 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'command' | 'comment' | 'complementary' | 'composite' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'generic' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'input' | 'landmark' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'mark' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'meter' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'range' | 'region' | 'roletype' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'section' | 'sectionhead' | 'select' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'structure' | 'suggestion' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | 'widget' | 'window';

// File: types/suffixTypes.d.ts
/** Suffix slots. */
export interface SuffixSlots {
    suffix?(props: any): any;
}
/** Suffix properties. */
export type SuffixProps = {
    suffix?: string | number;
    suffixId?: string;
};

// File: types/textTypes.d.ts
/** Text indexing system. */
export type TextValue = string | (() => string) | undefined;
export type TextIndex = 'cancel' | 'characterLimit' | 'characterRemaining' | 'close' | 'copiedClipboard' | 'decrement' | 'entriesMatch' | 'hide' | 'increment' | 'loading' | 'next' | 'notifications' | 'ok' | 'previous' | 'show' | string;
export type TextList = Record<TextIndex, TextValue>;
export type TextCancelPropsInclude = { textCancel?: TextValue; };
export type TextCharacterLimitPropsInclude = { textCharacterLimit?: TextValue; };
export type TextCharacterRemainingPropsInclude = { textCharacterRemaining?: TextValue; };
export type TextClosePropsInclude = { textClose?: TextValue; };
export type TextCopiedClipboardPropsInclude = { textCopiedClipboard?: TextValue; };
export type TextDecrementPropsInclude = { textDecrement?: TextValue; };
export type TextEntriesMatchPropsInclude = { textEntriesMatch?: TextValue; };
export type TextHidePropsInclude = { textHide?: TextValue; };
export type TextIncrementPropsInclude = { textIncrement?: TextValue; };
export type TextLoadingPropsInclude = { textLoading?: TextValue; };
export type TextNextPropsInclude = { textNext?: TextValue; };
export type TextNotificationsPropsInclude = { textNotifications?: TextValue; };
export type TextOkPropsInclude = { textOk?: TextValue; };
export type TextPreviousPropsInclude = { textPrevious?: TextValue; };
export type TextShowPropsInclude = { textShow?: TextValue; };
export type TextAllPropsInclude = TextCancelPropsInclude & TextCharacterLimitPropsInclude & TextCharacterRemainingPropsInclude & TextClosePropsInclude & TextCopiedClipboardPropsInclude & TextDecrementPropsInclude & TextEntriesMatchPropsInclude & TextHidePropsInclude & TextIncrementPropsInclude & TextLoadingPropsInclude & TextNextPropsInclude & TextNotificationsPropsInclude & TextOkPropsInclude & TextPreviousPropsInclude & TextShowPropsInclude;

// File: types/touchEventTypes.d.ts
/** Gesture directions. */
export type TouchEventTypeX = 'left' | 'right' | 'none';
export type TouchEventTypeY = 'top' | 'bottom' | 'none';
export type TouchEventClient = { x: number; y: number; };
/** Gesture callback. */
export type TouchEventCallback = (typeX: TouchEventTypeX, typeY: TouchEventTypeY, clientX: number, clientY: number, mouse?: TouchEventClient, mouseMove?: TouchEventClient, touche?: Touch, toucheMove?: Touch) => Promise<boolean> | boolean;