@evergis/uilib-gl 1.0.0

package/dist/molecules/CustomToggles/types.d.ts

@@ -0,0 +1,9 @@
+import { IIconProps, IconTypesKeys } from "../../atoms/Icon";
+import { IIconToggleProps } from "../IconToggle";
+export interface ICustomButtonProps extends Omit<IIconToggleProps, "kind"> {
+    kinds: [IconTypesKeys, IconTypesKeys];
+}
+export interface IFadingIconProps extends IIconProps {
+    isVisible?: boolean;
+}
+export declare type PasswordToggleProps = Omit<IIconToggleProps, "kind">;

package/dist/molecules/Expander/Expander.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IIconToggleProps } from "../IconToggle";
+export declare const Expander: FC<Omit<IIconToggleProps, "kind">>;

package/dist/molecules/Expander/index.d.ts

@@ -0,0 +1 @@
+export * from "./Expander";

package/dist/molecules/Expander/styled.d.ts

@@ -0,0 +1 @@
+export declare const RotatingButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, import("../IconButton").IconButtonProps & import("../CustomToggles").ICustomToggleProps, never>;

package/dist/molecules/FieldValue/FieldValue.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IFieldValueProps } from "./types";
+export declare const FieldValue: FC<IFieldValueProps>;

package/dist/molecules/FieldValue/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./FieldValue";
+export * from "./types";

package/dist/molecules/FieldValue/styled.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IFieldProps, IValueProps } from "./types";
+export declare const cropMixin: import("styled-components").FlattenSimpleInterpolation;
+export declare const Field: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, IFieldProps, never>;
+export declare const FieldContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const FieldValueExpander: import("styled-components").StyledComponent<import("react").FC<Omit<import("../IconToggle").IIconToggleProps, "kind">>, import("styled-components").DefaultTheme, {}, never>;
+export declare const Value: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, IValueProps, never>;

package/dist/molecules/FieldValue/types.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes, ReactNode } from "react";
+export interface IFieldValueProps extends HTMLAttributes<HTMLDivElement> {
+    field: ReactNode;
+    value: string;
+    fieldWrap?: boolean;
+    valueCrop?: boolean;
+    emptyValue?: string;
+    expandable?: boolean;
+    numeral?: boolean;
+    /**
+     * props for number value.
+     * it will works only if 'numeral' prop is truthy
+     */
+    delimiter?: string;
+    numeralDecimalMark?: string;
+    numeralDecimalScale?: number;
+    stripLeadingZeroes?: boolean;
+}
+export interface IFieldProps {
+    fieldWrap?: boolean;
+}
+export interface IValueProps {
+    valueCrop?: boolean;
+    value?: string;
+}

package/dist/molecules/HueMap/HueMap.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IHueMap } from "./types";
+export declare const HueMap: FC<IHueMap>;

package/dist/molecules/HueMap/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./HueMap";
+export * from "./types";

package/dist/molecules/HueMap/styled.d.ts

@@ -0,0 +1,12 @@
+import { IPointer } from "./types";
+export declare const Pointer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IPointer, never>;
+export declare const Map: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+interface IBackground {
+    bgColor: string;
+}
+export declare const Background: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IBackground, never>;
+export declare const LowerGradient: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const UpperGradient: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Hidden: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Container: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export {};

package/dist/molecules/HueMap/types.d.ts

@@ -0,0 +1,11 @@
+export interface IHueMap {
+    hue: number;
+    max?: number;
+    x: number;
+    y: number;
+    onChange: (x: number, y: number) => void;
+}
+export interface IPointer {
+    left: string;
+    bottom: string;
+}

package/dist/molecules/HueSlider/HueSlider.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { ISliderProps } from "../../organisms/Slider";
+export declare const HueSlider: FC<ISliderProps<false>>;

package/dist/molecules/HueSlider/index.d.ts

@@ -0,0 +1 @@
+export * from "./HueSlider";

package/dist/molecules/IconButton/IconButton.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IIconButtonProps } from "./types";
+export declare const IconButton: FC<IIconButtonProps>;

package/dist/molecules/IconButton/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IconButton";
+export * from "./styled";
+export * from "./types";

package/dist/molecules/IconButton/styled.d.ts

@@ -0,0 +1,4 @@
+import { IconButtonProps } from "./types";
+export declare const IconButtonInnerChild: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const buttonMixin: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IconButtonProps, import("styled-components").DefaultTheme>>;
+export declare const IconButtonButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, IconButtonProps, never>;

package/dist/molecules/IconButton/types.d.ts

@@ -0,0 +1,22 @@
+import { ButtonHTMLAttributes, ReactNode, MouseEvent } from "react";
+import { IconTypesKeys } from "../../atoms/Icon";
+export interface IIconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    kind?: IconTypesKeys;
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    tabIndex?: number;
+    innerRef?: (node: HTMLButtonElement | null) => void;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+    icon?: ReactNode;
+    iconRight?: boolean;
+}
+export interface IconButtonProps {
+    disabled?: boolean;
+    primary?: boolean;
+    secondary?: boolean;
+    tabIndex?: number;
+    error?: boolean;
+    notFixedWidth?: boolean;
+    iconRight?: boolean;
+}

package/dist/molecules/IconToggle/IconToggle.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IIconToggleProps } from "./types";
+export declare const IconToggle: FC<IIconToggleProps>;

package/dist/molecules/IconToggle/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IconToggle";
+export * from "./styled";
+export * from "./types";

package/dist/molecules/IconToggle/styled.d.ts

@@ -0,0 +1,3 @@
+import { IIconToggleButtonProps } from "./types";
+export declare const IconToggleText: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const IconToggleButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, IIconToggleButtonProps, never>;

package/dist/molecules/IconToggle/types.d.ts

@@ -0,0 +1,20 @@
+import { MouseEvent, ButtonHTMLAttributes } from "react";
+import { IconTypesKeys } from "../../atoms/Icon";
+import { IconButtonProps } from "../IconButton";
+export interface IIconToggleProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    innerRef?: (node: null | HTMLElement) => void;
+    kind?: IconTypesKeys;
+    isSelected?: boolean;
+    accent?: boolean;
+    tabIndex?: number;
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    onClick?: (e?: MouseEvent<HTMLButtonElement>) => void;
+}
+export interface IIconToggleButtonProps extends IconButtonProps {
+    isSelected?: boolean;
+    accent?: boolean;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+}
+export declare type IIconToggleSortProps = Omit<IIconToggleProps, "kind">;

package/dist/molecules/Input/CheckMark.d.ts

@@ -0,0 +1 @@
+export declare const CheckMark: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, import("../../atoms/Icon").IIconProps, never>;

package/dist/molecules/Input/Containers.d.ts

@@ -0,0 +1,6 @@
+export declare const InputContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    disabled?: boolean | undefined;
+    error?: boolean | undefined;
+    width?: string | undefined;
+    active?: boolean | undefined;
+}, never>;

package/dist/molecules/Input/Help.d.ts

@@ -0,0 +1,2 @@
+import { IHelpProps } from "./types";
+export declare const Help: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, IHelpProps, never>;

package/dist/molecules/Input/IconContainers.d.ts

@@ -0,0 +1,4 @@
+export declare const IconBefore: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const IconAfter: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    indent: number;
+}, never>;

package/dist/molecules/Input/Input.d.ts

@@ -0,0 +1,394 @@
+import React from "react";
+export declare const Input: {
+    new (props: (React.InputHTMLAttributes<HTMLInputElement> & {
+        label?: React.ReactNode;
+        asChip?: boolean | undefined;
+        help?: React.ReactNode;
+        width?: string | undefined;
+        height?: string | undefined;
+        iconBefore?: React.ReactNode;
+        valuePrefix?: React.ReactNode;
+        error?: boolean | undefined;
+        innerRef?: RefType<HTMLInputElement>;
+        success?: boolean | undefined;
+        disableInputOnly?: boolean | undefined;
+        onRemove?: (() => void) | undefined;
+        onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        active?: boolean | undefined;
+    } & import("../../hoc").IwithLabelProps<HTMLInputElement>) | Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+        label?: React.ReactNode;
+        asChip?: boolean | undefined;
+        help?: React.ReactNode;
+        width?: string | undefined;
+        height?: string | undefined;
+        iconBefore?: React.ReactNode;
+        valuePrefix?: React.ReactNode;
+        error?: boolean | undefined;
+        innerRef?: RefType<HTMLInputElement>;
+        success?: boolean | undefined;
+        disableInputOnly?: boolean | undefined;
+        onRemove?: (() => void) | undefined;
+        onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        active?: boolean | undefined;
+    } & import("../../hoc").IwithLabelProps<HTMLInputElement>>): {
+        state: import("../../hoc").IState;
+        onFocus: (e: React.FocusEvent<HTMLInputElement, Element>) => void;
+        onBlur: (e: React.FocusEvent<HTMLInputElement, Element>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "focused">(state: import("../../hoc").IState | ((prevState: Readonly<import("../../hoc").IState>, props: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>) => import("../../hoc").IState | Pick<import("../../hoc").IState, K> | null) | Pick<import("../../hoc").IState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, prevState: Readonly<import("../../hoc").IState>): any;
+        componentDidUpdate?(prevProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, prevState: Readonly<import("../../hoc").IState>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): void;
+    };
+    new (props: React.InputHTMLAttributes<HTMLInputElement> & {
+        label?: React.ReactNode;
+        asChip?: boolean | undefined;
+        help?: React.ReactNode;
+        width?: string | undefined;
+        height?: string | undefined;
+        iconBefore?: React.ReactNode;
+        valuePrefix?: React.ReactNode;
+        error?: boolean | undefined;
+        innerRef?: RefType<HTMLInputElement>;
+        success?: boolean | undefined;
+        disableInputOnly?: boolean | undefined;
+        onRemove?: (() => void) | undefined;
+        onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+        active?: boolean | undefined;
+    } & import("../../hoc").IwithLabelProps<HTMLInputElement>, context: any): {
+        state: import("../../hoc").IState;
+        onFocus: (e: React.FocusEvent<HTMLInputElement, Element>) => void;
+        onBlur: (e: React.FocusEvent<HTMLInputElement, Element>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "focused">(state: import("../../hoc").IState | ((prevState: Readonly<import("../../hoc").IState>, props: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>) => import("../../hoc").IState | Pick<import("../../hoc").IState, K> | null) | Pick<import("../../hoc").IState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, prevState: Readonly<import("../../hoc").IState>): any;
+        componentDidUpdate?(prevProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, prevState: Readonly<import("../../hoc").IState>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<React.InputHTMLAttributes<HTMLInputElement> & {
+            label?: React.ReactNode;
+            asChip?: boolean | undefined;
+            help?: React.ReactNode;
+            width?: string | undefined;
+            height?: string | undefined;
+            iconBefore?: React.ReactNode;
+            valuePrefix?: React.ReactNode;
+            error?: boolean | undefined;
+            innerRef?: RefType<HTMLInputElement>;
+            success?: boolean | undefined;
+            disableInputOnly?: boolean | undefined;
+            onRemove?: (() => void) | undefined;
+            onKeyPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            onKeyDown?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+            active?: boolean | undefined;
+        } & import("../../hoc").IwithLabelProps<HTMLInputElement>>, nextState: Readonly<import("../../hoc").IState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/molecules/Input/InputField.d.ts

@@ -0,0 +1,7 @@
+import { IInputFieldProps } from "./types";
+export declare const inputMixin: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IInputFieldProps, import("styled-components").DefaultTheme>>;
+export declare const StyledInput: import("styled-components").StyledComponent<"input", import("styled-components").DefaultTheme, IInputFieldProps, never>;
+export declare const ChipInputHolder: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IInputFieldProps, never>;
+export declare const ValuePrefix: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    prefixWidth?: number | undefined;
+}, never>;

package/dist/molecules/Input/Label.d.ts

@@ -0,0 +1,2 @@
+import { IInputLabelProps } from "./types";
+export declare const InputLabel: import("styled-components").StyledComponent<"label", import("styled-components").DefaultTheme, IInputLabelProps, never>;

package/dist/molecules/Input/MaskedComponent.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const MaskedComponent: React.ComponentType<any>;

package/dist/molecules/Input/WideChip.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { IChipProps } from "../Chip";
+export declare const WideChip: import("styled-components").StyledComponent<({ ...props }: IChipProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;

package/dist/molecules/Input/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Input";
+export * from "./Label";
+export * from "./MaskedComponent";
+export * from "./types";