@homecode/ui 4.11.1

package/dist/esm/types/src/components/Form/Form.d.ts

@@ -0,0 +1,32 @@
+import { Component } from 'react';
+import * as T from './Form.types';
+export declare class Form extends Component<T.Props> {
+    store: any;
+    validationSchema: T.FormValidationSchema;
+    defaultValues: T.FormValues;
+    constructor(props: T.Props);
+    componentDidMount(): void;
+    shouldComponentUpdate({ defaultValues, initialValues, validationSchema, }: T.Props): boolean;
+    updateDefaultValues(props?: Readonly<T.Props>): T.FormValues;
+    setInitialVals(initialValues?: {}): void;
+    setValue: (field: any, val: any) => void;
+    setValues: (vals: any) => any;
+    setDisabled: (name: string | object, isDisabled?: any) => void;
+    reset: () => void;
+    field: (props: T.FieldProps) => JSX.Element;
+    getFieldProps(props: any): T.FormFieldProps;
+    getFormAPI(): T.FormAPI;
+    getValidationState(store?: any): T.ValidationState;
+    getValidationErrors(store?: T.ValidationStateParams): any;
+    calcChanged(field: string, val: any): void;
+    calcChangedAll(initialValues?: T.FormValues): void;
+    validate(): void;
+    onInit(): void;
+    onSubmit: (e: any) => Promise<void>;
+    onChange: (field: string, val: any) => void;
+    onBlur: (name: string) => void;
+    handleChange(field: string, val: any): void;
+    render(): JSX.Element;
+}
+export * from './SubmitButtons/SubmitButtons';
+export * as FormTypes from './Form.types';

package/dist/esm/types/src/components/Form/Form.helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function patchWithCustomMessages(checkRes: any, validationSchema: any): any;
+export declare function dropFocusFromSubmit(): void;
+export declare function getInitialTouched(initialValues: any): {};
+export declare function getNotEmpty(_defaultValues: any, values: any): {};
+export declare function getVal(e: any, val: any, valField: any): any;
+export declare function cloneValues(values: any): {};

package/dist/esm/types/src/components/Form/Form.types.d.ts

@@ -0,0 +1,71 @@
+import { ReactNode } from 'react';
+import { ValidationSchema, ValidationError } from 'fastest-validator';
+import type { ComponentType, FormFieldChangeHandler } from 'uilib/types';
+export type FormValidationSchema = ValidationSchema;
+export type FormValues = Record<string, any>;
+type FieldError = {
+    type: string;
+    message: string;
+    expected?: boolean;
+    actual?: boolean;
+};
+type FieldsFlags = Record<string, boolean>;
+type FieldsErrors = Record<string, FieldError>;
+export type ValidationStateParams = {
+    values: FormValues;
+    disabled: FieldsFlags;
+};
+export type ValidationState = {
+    isValid: boolean;
+    errors: FieldsErrors;
+};
+export type FormAPI = ValidationState & {
+    isDirty: boolean;
+    isLoading: boolean;
+    values: FormValues;
+    touched: FieldsFlags;
+    changed: FieldsFlags;
+    setValue: (field: string, val: any) => void;
+    setValues: (values: FormValues) => void;
+    reset: () => void;
+    Field: (props: FormFieldProps) => ReactNode;
+};
+export type FormValidationRule = {
+    type?: string;
+    check?: (value: any, schema: FormValidationSchema, values: FormValues) => boolean;
+    messages?: {
+        [id: string]: string;
+    };
+};
+export type Props = ComponentType & {
+    defaultValues?: FormValues;
+    initialValues: FormValues;
+    defaultDisabled?: FieldsFlags;
+    validationSchema?: FormValidationSchema;
+    markEdited?: boolean;
+    children: (api: FormAPI) => ReactNode | ReactNode[];
+    onInit?: (api: FormAPI) => boolean | void;
+    onChange?: (values: FormValues) => void;
+    onSubmit?: (values: FormValues) => Promise<void>;
+};
+export type FieldProps = {
+    name: string;
+    className?: string;
+    onChange: FormFieldChangeHandler;
+    onBlur?(e: FocusEvent): boolean | void;
+    markEdited?: Props['markEdited'];
+    value: any;
+    isHidden: boolean;
+    component?: (props: FormFieldProps) => ReactNode;
+    children?: ReactNode;
+};
+export type FormFieldProps = FieldProps & {
+    value: any;
+    error: ValidationError;
+    isChanged: boolean;
+    isTouched: boolean;
+    clearMargins: boolean;
+    handleChange: (name: string, val: any) => void;
+    handleBlur: (name: string) => void;
+};
+export {};

package/dist/esm/types/src/components/Form/SubmitButtons/SubmitButtons.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../../Button/Button';
+export type ButtonConfig = ButtonProps & {
+    key: string;
+    children?: ReactNode;
+};
+type Props = {
+    className?: string;
+    buttons: ButtonConfig[];
+    children?: ReactNode;
+};
+export declare const SubmitButtons: ({ buttons, className, ...props }: Props) => JSX.Element;
+export {};

package/dist/esm/types/src/components/Form/Validator.d.ts

@@ -0,0 +1,2 @@
+import FastestValidator from 'fastest-validator';
+export declare const Validator: FastestValidator;

package/dist/esm/types/src/components/Form/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SubmitButtons/SubmitButtons';
+export * from './Form';

package/dist/esm/types/src/components/Gallery/Dots/Dots.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export default function Dots({ index, count }: {
+    index: any;
+    count: any;
+}): JSX.Element;

package/dist/esm/types/src/components/Gallery/Gallery.d.ts

@@ -0,0 +1,36 @@
+import { Component } from 'react';
+import * as T from './Gallery.types';
+type Direction = -1 | 1;
+export declare class Gallery extends Component<T.Props> {
+    store: any;
+    items: any;
+    index: number;
+    timers: any;
+    startX: any;
+    innerRef: import("react").RefObject<HTMLDivElement>;
+    static defaultProps: {
+        size: string;
+        animation: boolean;
+        startIndex: number;
+    };
+    constructor(props: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: any): void;
+    getStateItems(): any[];
+    recenter(): void;
+    init(): void;
+    subscribe(): void;
+    isSingle: () => boolean;
+    onKeyDown: (e: any) => void;
+    onPointerDown: (e: any) => void;
+    onPointerMove: (e: any) => void;
+    onPointerUp: (e: any) => void;
+    getDelta: (e: any) => number;
+    setTransformDelta: (delta: number) => void;
+    removeTransformDelta: () => void;
+    move: (direction: Direction) => void;
+    switch(direction: Direction): void;
+    render(): JSX.Element;
+}
+export {};

package/dist/esm/types/src/components/Gallery/Gallery.types.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentType, Size } from 'uilib/types';
+export type Props = ComponentType & {
+    items: string[];
+    size?: Size;
+    animation?: boolean;
+    startIndex?: number;
+    showArrows?: boolean;
+    showDots?: boolean;
+    initialBounce?: boolean;
+    cover: true;
+    onChange?: (index: number, item: string) => void;
+};

package/dist/esm/types/src/components/Heading/Heading.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './Heading.types';
+export declare const Heading: import("react").NamedExoticComponent<T.Props>;

package/dist/esm/types/src/components/Heading/Heading.types.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export type Props = {
+    id: string;
+    text: ReactNode;
+};

package/dist/esm/types/src/components/Icon/Icon.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="react" />
+import * as T from './Icon.types';
+export declare const icons: {
+    avatar: () => Promise<any>;
+    brokenImage: () => Promise<any>;
+    check: () => Promise<any>;
+    close: () => Promise<any>;
+    colors: () => Promise<any>;
+    chevronUp: () => Promise<any>;
+    chevronDown: () => Promise<any>;
+    chevronRight: () => Promise<any>;
+    chevronLeft: () => Promise<any>;
+    delete: () => Promise<any>;
+    draft: () => Promise<any>;
+    edit: () => Promise<any>;
+    externalLink: () => Promise<any>;
+    fullscreen: () => Promise<any>;
+    fullscreenExit: () => Promise<any>;
+    gear: () => Promise<any>;
+    history: () => Promise<any>;
+    home: () => Promise<any>;
+    loader: () => Promise<any>;
+    menu: () => Promise<any>;
+    mic: () => Promise<any>;
+    minus: () => Promise<any>;
+    moreVertical: () => Promise<any>;
+    moreHorizontal: () => Promise<any>;
+    plus: () => Promise<any>;
+    redo: () => Promise<any>;
+    undo: () => Promise<any>;
+    requiredStar: () => Promise<any>;
+    send: () => Promise<any>;
+    settings: () => Promise<any>;
+    shoppingBag: () => Promise<any>;
+    social_instagram: () => Promise<any>;
+    social_telegram: () => Promise<any>;
+    social_email: () => Promise<any>;
+};
+export type { IconType } from './Icon.types';
+export declare function Icon(props: T.Props): JSX.Element;
+export declare namespace Icon {
+    var defaultProps: {
+        size: T.IconSize;
+    };
+}

package/dist/esm/types/src/components/Icon/Icon.example.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: () => JSX.Element;
+export default _default;

package/dist/esm/types/src/components/Icon/Icon.helpers.d.ts

@@ -0,0 +1 @@
+export declare function createFaName(name: any): string;

package/dist/esm/types/src/components/Icon/Icon.types.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType, Size } from 'uilib/types';
+import CUSTOM_ICONS from './icons';
+export type IconSize = 'xs' | Size;
+export type IconType = keyof typeof CUSTOM_ICONS;
+export type Props = ComponentType & {
+    type: IconType;
+    size: IconSize;
+};

package/dist/esm/types/src/components/Icon/icons/index.d.ts

@@ -0,0 +1,39 @@
+declare const _default: {
+    avatar: () => Promise<any>;
+    brokenImage: () => Promise<any>;
+    check: () => Promise<any>;
+    close: () => Promise<any>;
+    colors: () => Promise<any>;
+    copy: () => Promise<any>;
+    chevronUp: () => Promise<any>;
+    chevronDown: () => Promise<any>;
+    chevronRight: () => Promise<any>;
+    chevronLeft: () => Promise<any>;
+    delete: () => Promise<any>;
+    draft: () => Promise<any>;
+    edit: () => Promise<any>;
+    externalLink: () => Promise<any>;
+    fullscreen: () => Promise<any>;
+    fullscreenExit: () => Promise<any>;
+    gear: () => Promise<any>;
+    history: () => Promise<any>;
+    home: () => Promise<any>;
+    loader: () => Promise<any>;
+    menu: () => Promise<any>;
+    mic: () => Promise<any>;
+    minus: () => Promise<any>;
+    moreVertical: () => Promise<any>;
+    moreHorizontal: () => Promise<any>;
+    plus: () => Promise<any>;
+    redo: () => Promise<any>;
+    undo: () => Promise<any>;
+    requiredStar: () => Promise<any>;
+    save: () => Promise<any>;
+    send: () => Promise<any>;
+    settings: () => Promise<any>;
+    shoppingBag: () => Promise<any>;
+    social_instagram: () => Promise<any>;
+    social_telegram: () => Promise<any>;
+    social_email: () => Promise<any>;
+};
+export default _default;

package/dist/esm/types/src/components/Input/Input.d.ts

@@ -0,0 +1,42 @@
+import { Component, ChangeEvent } from 'react';
+import * as T from './Input.types';
+export type InputProps = T.Props;
+export declare class Input extends Component<T.Props> {
+    inputRef: import("react").RefObject<HTMLInputElement>;
+    isClearPressed: boolean;
+    cursorPos: number;
+    prevLabelText: string;
+    store: any;
+    uid: any;
+    static defaultProps: {
+        type: string;
+        size: string;
+        variant: string;
+    };
+    constructor(props: T.Props);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: T.Props): void;
+    updateAutoComplete(): void;
+    updateSelection(): void;
+    updateLabelPosition(): void;
+    updateHasValue(): void;
+    hasValue(value?: any): boolean;
+    isTextArea: () => boolean;
+    isLabelOnTop(hasValue?: any): any;
+    getValue(val?: any): any;
+    onTextareaPaste: (e: any) => void;
+    pasteToTextarea: any;
+    onClearPress: (e: any) => void;
+    onDocKeyUp: (e: KeyboardEvent) => void;
+    handleChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onChange: (value: any, e?: any) => void;
+    onTextAreaInput: (e: any) => void;
+    onLabelClipPathChange: (clipPath: string) => string;
+    onTypingEnd: () => void;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    getControlProps(): T.ControlProps;
+    wrapControll(control: any): any;
+    renderAddon(type: 'right' | 'left'): JSX.Element;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/Input/Input.types.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode, HTMLProps, InputHTMLAttributes } from 'react';
+import { ComponentType, FormControl, Size } from '../../types';
+export type ControlProps = HTMLProps<HTMLInputElement>;
+export type Value = string | number;
+export type Props = Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> & Omit<ControlProps, 'ref'> & FormControl<Value> & {
+    name?: string;
+    size?: Size;
+    label?: string;
+    variant?: 'default' | 'outlined';
+    forceLabelOnTop?: boolean;
+    error?: string | boolean;
+    hasClear?: boolean;
+    changeOnEnd?: boolean;
+    addonLeft?: string | ReactNode;
+    addonLeftClassName?: string;
+    addonRight?: string | ReactNode;
+    addonRightClassName?: string;
+    onClear?: () => void;
+    controlProps?: ControlProps & ComponentType;
+    checkAutofill?: boolean;
+};

package/dist/esm/types/src/components/InputFile/InputFile.d.ts

@@ -0,0 +1,48 @@
+import { Component } from 'react';
+import * as T from './InputFile.types';
+export * as InputFileTypes from './InputFile.types';
+export declare class InputFile extends Component<T.Props> {
+    store: any;
+    filesToUpload: any[];
+    previewRequests: {};
+    inputRef: import("react").RefObject<HTMLInputElement>;
+    _mounted: boolean;
+    constructor(props: any);
+    static defaultProps: {
+        size: string;
+        variant: string;
+        maxCount: number;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: any): void;
+    isMultiple: () => boolean;
+    getStateFromProps(): {
+        loaded: any;
+        index: any;
+        src: any;
+        total: number;
+        error: any;
+        base64: string;
+    }[];
+    getValFromState: () => any;
+    getLastIndex: () => number;
+    filterAllowedFiles(files: any, index: any): any[];
+    onPlusButtonClick: () => void;
+    onItemClick(index: any): void;
+    onDragStart: () => boolean;
+    onDragEnd: () => boolean;
+    onChange: (e: any) => Promise<void>;
+    onReorder: (ids: any) => void;
+    onProgress: (state: any) => (e: any) => void;
+    generatePreview(file: any, index: any): Promise<void>;
+    processUploadOnDemand(): Promise<void>;
+    processUploadOnChange(files: any): Promise<void>;
+    upload(file: any, index: any): Promise<void>;
+    demandedUploader: (upload: any) => Promise<any>;
+    remove: (e: any, value: any) => Promise<void>;
+    renderPlusButton(): JSX.Element;
+    renderItem: (i: any, props?: {}) => JSX.Element;
+    renderItems(): any;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/InputFile/InputFile.types.d.ts

@@ -0,0 +1,22 @@
+import { HTMLProps } from 'react';
+import type { Size, FormFieldChangeHandler } from 'uilib/types';
+type Uploader = (UploaderParams: any) => Promise<string>;
+type Accept = HTMLProps<HTMLInputElement>['accept'];
+type Value = string[];
+export type Props = {
+    className?: string;
+    label?: string;
+    size?: Size;
+    variant?: 'default' | 'outlined';
+    draggable?: boolean;
+    upload: Uploader;
+    uploadOnDemand?: (Uploader: any) => void;
+    accept?: Accept;
+    limit?: number;
+    maxCount?: number;
+    value?: Value;
+    onSelect?: (files: File[]) => void;
+    onChange: FormFieldChangeHandler;
+    remove?: (fileName: string) => Promise<boolean>;
+};
+export {};

package/dist/esm/types/src/components/InputFile/Item/Item.d.ts

@@ -0,0 +1,16 @@
+import { HTMLProps, ReactNode } from 'react';
+import type { Size } from 'uilib/types';
+type Props = {
+    className?: string;
+    size?: Size;
+    img?: string;
+    onRemove?: HTMLProps<HTMLButtonElement>['onClick'];
+    onClick?: () => void;
+    children?: ReactNode;
+    total: number;
+    loaded: number;
+    waitingForUpload?: boolean;
+    isDragging?: boolean;
+};
+export default function Item(props: Props): JSX.Element;
+export {};

package/dist/esm/types/src/components/Label/Label.d.ts

@@ -0,0 +1,19 @@
+import { Component } from 'react';
+import * as T from './Label.types';
+export declare class Label extends Component<T.Props> {
+    gapWrapRef: import("react").RefObject<HTMLDivElement>;
+    gapRef: import("react").RefObject<HTMLDivElement>;
+    timers: any;
+    state: {
+        clipPath: string;
+    };
+    labelWidth: number;
+    static defaultProps: {
+        size: string;
+    };
+    constructor(props: any);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    updateClipPath: () => void;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/Label/Label.helpers.d.ts

@@ -0,0 +1 @@
+export declare function getLabelClipPath(left: any, width: any, size?: string): string;

package/dist/esm/types/src/components/Label/Label.types.d.ts

@@ -0,0 +1,8 @@
+export type Props = {
+    className?: string;
+    size?: string;
+    children: string;
+    isOnTop: boolean;
+    isError?: boolean;
+    onClipPathChange?: (clipPath: string) => void;
+};

package/dist/esm/types/src/components/Lazy/Lazy.d.ts

@@ -0,0 +1,18 @@
+import { Component, ComponentType } from 'react';
+import * as T from './Lazy.types';
+export declare class Lazy extends Component<T.Props> {
+    store: T.State;
+    Node?: ComponentType<any>;
+    hasNode: boolean;
+    clearSpinnerTimeout: null;
+    static defaultProps: {
+        size: string;
+    };
+    constructor(props: T.Props);
+    componentDidMount(): void;
+    componentDidUpdate({ loader }: {
+        loader: any;
+    }): void;
+    update(): void;
+    render(): string | number | boolean | import("react").ReactFragment | JSX.Element;
+}

package/dist/esm/types/src/components/Lazy/Lazy.types.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import type { Size } from 'uilib/types';
+export type Loader = () => Promise<{
+    default: ReactNode;
+}>;
+export type Props = {
+    loader: Loader;
+    size?: Size;
+    progressElem?: ReactNode;
+    hideSpinner?: boolean;
+};
+export type State = {
+    loading: boolean;
+    spinnerTimeout: boolean;
+};

package/dist/esm/types/src/components/LightBox/LightBox.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './LightBox.types';
+export declare function LightBox({ children, onClose, blur, ...props }: T.Props): JSX.Element;

package/dist/esm/types/src/components/LightBox/LightBox.types.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type Props = {
+    isOpen?: boolean;
+    onClose?: () => void;
+    children: ReactNode;
+    blur?: boolean;
+};

package/dist/esm/types/src/components/Notifications/Notifications.d.ts

@@ -0,0 +1,2 @@
+export declare const NotificationsStore: any;
+export declare const Notifications: any;

package/dist/esm/types/src/components/Notifications/Notifications.types.d.ts

@@ -0,0 +1,19 @@
+export type NotificationType = 'warning' | 'danger' | 'loading';
+type Id = string;
+export type ItemParams = {
+    type?: NotificationType;
+    title?: string;
+    content?: string;
+};
+export type Methods = {
+    show: (data: ItemParams) => Id;
+    pause: () => void;
+    unpause: () => void;
+    close: (id: Id) => void;
+    remove: (id: Id) => void;
+};
+export type ItemProps = ItemParams & Methods & {
+    id: string;
+    visible: boolean;
+};
+export {};

package/dist/esm/types/src/components/Notifications/store.d.ts

@@ -0,0 +1,2 @@
+declare const STORE: any;
+export default STORE;

package/dist/esm/types/src/components/Paranja/Paranja.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './Paranja.types';
+export declare const Paranja: ({ className, children, visible, inline, blur, }: T.Props) => JSX.Element;

package/dist/esm/types/src/components/Paranja/Paranja.types.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+export type Props = {
+    children?: ReactNode;
+    className?: string;
+    visible?: boolean;
+    inline?: boolean;
+    blur?: boolean;
+};

package/dist/esm/types/src/components/Popup/Popup.d.ts

@@ -0,0 +1,73 @@
+import { Component } from 'react';
+import * as T from './Popup.types';
+export declare const ANIMATION_DURATION = 100;
+export type PopupProps = T.Props;
+export declare class Popup extends Component<T.Props> {
+    rootElem: import("react").RefObject<HTMLDivElement>;
+    triggerElem: import("react").RefObject<HTMLDivElement>;
+    containerElem: HTMLDivElement;
+    onContainerElemRef: (elem: any) => void;
+    focused: boolean;
+    pointerPressed: boolean;
+    subscribedHoverControl: boolean;
+    subscribedSizeChange: boolean;
+    pointerDownTarget: any;
+    isPointerPressedInside: boolean;
+    needDropOffset: boolean;
+    id: any;
+    parentPopupContent: any;
+    store: any;
+    timers: any;
+    scrollParent: any;
+    offset: {
+        top: number;
+        left: number;
+    };
+    static defaultProps: {
+        size: string;
+        direction: string;
+        animated: boolean;
+    };
+    constructor(props: any);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: T.Props): void;
+    componentWillUnmount(): void;
+    subscribeSizeChange(): void;
+    subscribeScroll(): void;
+    unsubscribeScroll(): void;
+    unsubscribeSizeChange(): void;
+    subscribeHoverControl(): void;
+    unsubscribeHoverControl(): void;
+    updateBounds(): void;
+    updateBoundsThrottled: any;
+    prevContentBounds: {
+        width: number;
+        height: number;
+    };
+    updateOffset: () => void;
+    applyOffset(): void;
+    checkHover: any;
+    isLastClickInside: () => any;
+    onDocPointerDown: (e: PointerEvent) => void;
+    onDocPointerUp: (e: PointerEvent) => void;
+    isPointerOver(target: any, elem: any): any;
+    onScroll: any;
+    onDocKeyDown: (e: KeyboardEvent) => void;
+    onDocKeyUp: (e: KeyboardEvent) => void;
+    onTriggerPointerDown: (e: any) => void;
+    onTriggerPointerUp: (e: any) => void;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    onTriggerResize: () => void;
+    onContainerResize: () => void;
+    open: any;
+    close: () => void;
+    changeState(isOpen: boolean, callback: any): void;
+    afterOpen: () => void;
+    afterClose: () => void;
+    dropOffset(): void;
+    toggle: any;
+    renderTrigger(): JSX.Element;
+    renderContent(): JSX.Element;
+    render(): JSX.Element;
+}