@salutejs/plasma-new-hope 0.173.0-canary.1497.11459278795.0 → 0.173.0-dev.0

package/types/examples/plasma_web/components/TextField/TextField.d.ts

@@ -19,6 +19,13 @@ export declare const TextField: import("react").FunctionComponent<import("../../
     clear: {
         true: import("@linaria/core").LinariaClassName;
     };
+    hintView: {
+        default: import("@linaria/core").LinariaClassName;
+    };
+    hintSize: {
+        m: import("@linaria/core").LinariaClassName;
+        s: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -33,6 +40,7 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -47,6 +55,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: boolean | undefined;
     hasDivider?: boolean | undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -60,6 +79,7 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -74,6 +94,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: boolean | undefined;
     hasDivider?: boolean | undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;
@@ -87,6 +118,85 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -101,6 +211,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: false | undefined;
     hasDivider?: undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -114,6 +235,7 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -128,6 +250,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: false | undefined;
     hasDivider?: undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;
@@ -141,6 +274,124 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -155,6 +406,56 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: boolean | undefined;
     hasDivider?: boolean | undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -168,6 +469,7 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -182,6 +484,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: boolean | undefined;
     hasDivider?: boolean | undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;
@@ -195,6 +508,7 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -209,6 +523,17 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: false | undefined;
     hasDivider?: undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -222,6 +547,46 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     label?: string | undefined;
     labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
+} & {
+    hintText: string;
+    hintTrigger?: "click" | "hover" | undefined;
+    hintView?: string | undefined;
+    hintSize?: string | undefined;
+    hintTargetIcon?: import("react").ReactNode;
+    hintPlacement?: import("@popperjs/core").Placement | import("@popperjs/core").ComputedPlacement[] | undefined;
+    hintHasArrow?: boolean | undefined;
+    hintOffset?: [number, number] | undefined;
+    hintWidth?: string | undefined;
+    hintContentLeft?: import("react").ReactNode;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
     leftHelper?: string | undefined;
     contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
     contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
@@ -236,6 +601,56 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     clear?: false | undefined;
     hasDivider?: undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    titleCaption?: import("react").ReactNode;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
+} & {
+    hintTrigger?: undefined;
+    hintText?: undefined;
+    hintView?: undefined;
+    hintSize?: undefined;
+    hintTargetIcon?: undefined;
+    hintPlacement?: undefined;
+    hintHasArrow?: undefined;
+    hintOffset?: undefined;
+    hintWidth?: undefined;
+    hintContentLeft?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;

package/types/examples/plasma_web/components/TextField/TextField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextField.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAA0B,CAAC"}
+{"version":3,"file":"TextField.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAA0B,CAAC"}

package/types/hooks/useOutsideClick.d.ts

@@ -1,3 +1,3 @@
 import type { RefObject } from 'react';
-export declare const useOutsideClick: <T extends HTMLElement = HTMLElement>(callback: (event: MouseEvent | TouchEvent) => void, secondaryRef?: RefObject<HTMLElement | null> | null | undefined) => import("react").MutableRefObject<T | null>;
+export declare const useOutsideClick: <T extends HTMLElement = HTMLElement>(callback: () => void, secondaryRef?: RefObject<HTMLElement | null> | null | undefined) => import("react").MutableRefObject<T | null>;
 //# sourceMappingURL=useOutsideClick.d.ts.map

package/types/hooks/useOutsideClick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOutsideClick.d.ts","sourceRoot":"","sources":["../../src/hooks/useOutsideClick.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,eAAO,MAAM,eAAe,0DACN,UAAU,GAAG,UAAU,KAAK,IAAI,gHA2BrD,CAAC"}
+{"version":3,"file":"useOutsideClick.d.ts","sourceRoot":"","sources":["../../src/hooks/useOutsideClick.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,eAAO,MAAM,eAAe,kDACd,MAAM,IAAI,gHA0BvB,CAAC"}

package/types/utils/getPopoverPlacement.d.ts

@@ -1,5 +1,6 @@
+import { PopoverPlacementBasic } from '../components/Popover';
 export declare type PlacementBasic = 'top' | 'bottom' | 'right' | 'left';
 export declare type Placement = PlacementBasic | 'auto';
-export declare const getPlacement: (placement: Placement) => import("@popperjs/core").ComputedPlacement;
-export declare const getPlacements: (placements?: Placement | PlacementBasic[] | undefined) => import("@popperjs/core").ComputedPlacement | import("@popperjs/core").ComputedPlacement[] | undefined;
+export declare const getPlacement: (placement: Placement) => PopoverPlacementBasic;
+export declare const getPlacements: (placements?: Placement | PlacementBasic[] | undefined) => PopoverPlacementBasic | PopoverPlacementBasic[] | undefined;
 //# sourceMappingURL=getPopoverPlacement.d.ts.map

package/types/utils/getPopoverPlacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPopoverPlacement.d.ts","sourceRoot":"","sources":["../../src/utils/getPopoverPlacement.ts"],"names":[],"mappings":"AAEA,oBAAY,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AACjE,oBAAY,SAAS,GAAG,cAAc,GAAG,MAAM,CAAC;AAEhD,eAAO,MAAM,YAAY,cAAe,SAAS,+CAEhD,CAAC;AAEF,eAAO,MAAM,aAAa,kKAUzB,CAAC"}
+{"version":3,"file":"getPopoverPlacement.d.ts","sourceRoot":"","sources":["../../src/utils/getPopoverPlacement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,oBAAY,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AACjE,oBAAY,SAAS,GAAG,cAAc,GAAG,MAAM,CAAC;AAEhD,eAAO,MAAM,YAAY,cAAe,SAAS,0BAEhD,CAAC;AAEF,eAAO,MAAM,aAAa,wHAUzB,CAAC"}

package/cjs/components/Dropdown/Dropdown.styles_18f0qpm.css

@@ -1,2 +0,0 @@
-.un7uamp{box-sizing:border-box;width:var(--un7uamp-0);height:var(--un7uamp-1);margin:var(--un7uamp-2);padding:var(--plasma-dropdown-padding) 0;overflow:var(--un7uamp-3);background:var(--surface-solid-card);box-shadow:0px 4px 14px -4px rgba(8,8,8,0.08),0px 1px 4px -1px rgba(0,0,0,0.04);border-radius:var(--plasma-dropdown-border-radius);}
-

package/cjs/components/Dropdown/FloatingPopover.js

@@ -1,104 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
-var react = require('@floating-ui/react');
-var React = require('react');
-var plasmaCore = require('@salutejs/plasma-core');
-
-var FloatingPopover = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
-  var target = _ref.target,
-    children = _ref.children,
-    opened = _ref.opened,
-    onToggle = _ref.onToggle,
-    placement = _ref.placement,
-    portal = _ref.portal,
-    _ref$offset = _ref.offset,
-    offset = _ref$offset === void 0 ? [0, 0] : _ref$offset,
-    isInner = _ref.isInner,
-    trigger = _ref.trigger;
-  var _useFloating = react.useFloating({
-      placement: placement === 'auto' ? undefined : placement,
-      open: opened,
-      middleware: [placement === 'auto' && react.autoPlacement(), react.offset({
-        mainAxis: offset[1],
-        crossAxis: offset[0]
-      }), react.flip({
-        fallbackAxisSideDirection: 'end'
-      }), react.shift()]
-    }),
-    refs = _useFloating.refs,
-    floatingStyles = _useFloating.floatingStyles;
-  var wrappedId = plasmaCore.safeUseId();
-  var handleTargetClick = function handleTargetClick(event) {
-    if (trigger === 'hover') {
-      return;
-    }
-    if (onToggle) {
-      onToggle(!opened, event);
-    }
-  };
-  var handleTargetMouseEnter = function handleTargetMouseEnter(event) {
-    if (trigger === 'click' || opened) {
-      return;
-    }
-    onToggle(true, event);
-  };
-  var handleTargetMouseLeave = function handleTargetMouseLeave(event) {
-    if (event.relatedTarget instanceof HTMLElement && refs.floating.current instanceof HTMLElement) {
-      var _refs$floating$curren;
-      if (trigger === 'click' || !opened || event.relatedTarget && refs.floating && (_refs$floating$curren = refs.floating.current) !== null && _refs$floating$curren !== void 0 && _refs$floating$curren.contains(event.relatedTarget)) {
-        return;
-      }
-      onToggle(false, event);
-    }
-  };
-  var handleFloatingMouseLeave = function handleFloatingMouseLeave(event) {
-    if (event.relatedTarget instanceof HTMLElement && refs.reference.current instanceof HTMLElement) {
-      var _refs$reference$curre;
-      if (trigger === 'click' || !opened || event.relatedTarget && refs.reference && (_refs$reference$curre = refs.reference.current) !== null && _refs$reference$curre !== void 0 && _refs$reference$curre.contains(event.relatedTarget)) {
-        return;
-      }
-      onToggle(false, event);
-    }
-  };
-  return /*#__PURE__*/React.createElement("div", {
-    id: wrappedId,
-    style: {
-      display: isInner ? 'block' : 'inline-block'
-    },
-    ref: ref
-  }, /*#__PURE__*/React.createElement("div", {
-    ref: refs.setReference,
-    onClick: handleTargetClick,
-    onMouseEnter: handleTargetMouseEnter,
-    onMouseLeave: handleTargetMouseLeave
-  }, target), opened && /*#__PURE__*/React.createElement(react.FloatingPortal, getFloatingPortalProps(portal, wrappedId), /*#__PURE__*/React.createElement("div", {
-    ref: refs.setFloating,
-    onMouseLeave: handleFloatingMouseLeave,
-    style: _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, floatingStyles), {}, {
-      zIndex: 1
-    })
-  }, children)));
-});
-// root - принимает ref контейнера портала.
-// id - если есть портал - не используется, если портала нет - подставляется 'wrappedId'.
-var getFloatingPortalProps = function getFloatingPortalProps(portal, wrappedId) {
-  if (!portal) {
-    return {
-      id: wrappedId
-    };
-  }
-  if (typeof portal === 'string') {
-    return {
-      id: portal
-    };
-  }
-  return {
-    root: portal
-  };
-};
-
-exports.FloatingPopover = FloatingPopover;
-//# sourceMappingURL=FloatingPopover.js.map