@membranehq/react 0.1.0

package/dist/types/components/DataBuilder/Formula/tpl.d.ts

@@ -0,0 +1,4 @@
+import { Formula as FormulaClass } from '@membranehq/sdk';
+import { FormulaProps } from './types';
+declare const TplFormula: import("react").ForwardRefExoticComponent<FormulaProps<FormulaClass.Tpl> & import("react").RefAttributes<HTMLDivElement>>;
+export default TplFormula;

package/dist/types/components/DataBuilder/Formula/types.d.ts

@@ -0,0 +1,15 @@
+import { ComboBoxOptionsFactory } from '../../../components/ComboBox/shared';
+export interface DropdownComponentFormulaProps<FormulaClass> {
+    formula: FormulaClass;
+    schema: any;
+    variablesSchema: any;
+    optionFactories?: ComboBoxOptionsFactory[];
+    onChange?: (value: any) => void;
+}
+export interface FormulaProps<FormulaClass> {
+    formula: FormulaClass;
+    variablesSchema: any;
+    disabled?: boolean;
+    onClick?: () => void;
+    onDelete?: () => void;
+}

package/dist/types/components/DataBuilder/Formula/var.d.ts

@@ -0,0 +1,4 @@
+import { Formula } from '@membranehq/sdk';
+import { FormulaProps } from './types';
+declare const VarFormula: import("react").ForwardRefExoticComponent<FormulaProps<Formula.Var> & import("react").RefAttributes<HTMLDivElement>>;
+export default VarFormula;

package/dist/types/components/DataBuilder/Nested/ArrayItems.d.ts

@@ -0,0 +1,5 @@
+import { IDataBuilderField } from '../data-field';
+export default function DataBuilderFormNestedArrayItems({ field, onChange, }: {
+    field: IDataBuilderField;
+    onChange: (value: any) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/DataBuilder/Nested/FieldControlPanel/AddingFieldSelector.d.ts

@@ -0,0 +1,7 @@
+import { IDataBuilderField } from '../../data-field';
+export declare function AddingFieldSelector({ parentField, fieldsToAdd, onChange, onClose, }: {
+    parentField: IDataBuilderField;
+    fieldsToAdd: IDataBuilderField[];
+    onChange: (value: string) => void;
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/Nested/FieldControlPanel/ControlPanel.d.ts

@@ -0,0 +1,7 @@
+import { IDataBuilderField } from '../../data-field';
+export declare function ControlPanel({ field, additionalFields, addFieldLabel, onAdd, }: {
+    field: IDataBuilderField;
+    additionalFields?: IDataBuilderField[];
+    addFieldLabel: string;
+    onAdd: (key: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/Nested/FieldControlPanel/ControlPanelForNonObjectRootField.d.ts

@@ -0,0 +1,4 @@
+export declare function ControlPanelForNonObjectRootField({ addFieldLabel, onAdd, }: {
+    addFieldLabel: string;
+    onAdd: (fieldKey: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/Nested/FieldControlPanel/index.d.ts

@@ -0,0 +1,10 @@
+import { ControlPanel } from './ControlPanel';
+import { ControlPanelForNonObjectRootField } from './ControlPanelForNonObjectRootField';
+import { IDataBuilderField } from '../../data-field';
+export { ControlPanelForNonObjectRootField, ControlPanel };
+export declare function DataBuilderFieldControlPanel({ field, onAdd, addFieldLabel, additionalFields, }: {
+    field: IDataBuilderField;
+    onAdd: (key: string) => void;
+    addFieldLabel?: string;
+    additionalFields?: IDataBuilderField[];
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/DataBuilder/Nested/FieldListWrapper/index.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+export declare function FieldListWrapper({ children, onClick, fieldsToShow, collapsed, }: PropsWithChildren<{
+    onClick: () => void;
+    fieldsToShow: number;
+    collapsed?: boolean;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/Nested/LevelKeysConflictProvider.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const LevelKeysConflictProvider: React.Provider<Set<string>>;
+export declare const useLevelKeysConflicts: () => Set<string>;

package/dist/types/components/DataBuilder/Nested/NoSchema.d.ts

@@ -0,0 +1,5 @@
+import { IDataBuilderField } from '../data-field';
+export default function DataBuilderFormNestedNoSchema({ field, onChange, }: {
+    field: IDataBuilderField;
+    onChange: (value: any) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/DataBuilder/Nested/ObjectFields.d.ts

@@ -0,0 +1,5 @@
+import { IDataBuilderField } from '../data-field';
+export default function DataBuilderFormNestedObjectFields({ field, onChange, }: {
+    field: IDataBuilderField;
+    onChange: (value: any) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/Nested/ValueMapping.d.ts

@@ -0,0 +1,2 @@
+import { IFieldComponent } from '../data-field';
+export declare function ValueMapping({ field, onChange }: IFieldComponent): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/DataBuilder/Nested.d.ts

@@ -0,0 +1,5 @@
+import { IDataBuilderField } from './data-field';
+export default function DataBuilderFormNested({ field, onChange, }: {
+    field: IDataBuilderField;
+    onChange: (value: any) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/data-builder-context.d.ts

@@ -0,0 +1,18 @@
+import { DataSchema } from '@membranehq/sdk';
+import { IDataBuilderField } from './data-field';
+import { IDataBuilderContext } from './types';
+export default function useDataBuilder(): IDataBuilderContext;
+export declare const DataBuilderProvider: ({ topLevelField, isAdminMode, children, errorFieldsLocators, frozenFieldsLocators, editableVariablesSchemaLocators, onAddVariable, readOnly, showNullValueFields, hideReadOnlyFields, collapsedDataBuilder, initialVisibleFieldCount, }: {
+    topLevelField: IDataBuilderField;
+    isAdminMode?: boolean;
+    readOnly?: boolean;
+    children: React.ReactNode;
+    errorFieldsLocators?: string[];
+    frozenFieldsLocators?: string[];
+    editableVariablesSchemaLocators?: string[];
+    onAddVariable?: (locator: string, schema: DataSchema) => void;
+    showNullValueFields?: boolean;
+    hideReadOnlyFields?: boolean;
+    collapsedDataBuilder?: boolean;
+    initialVisibleFieldCount?: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataBuilder/data-field.d.ts

@@ -0,0 +1,46 @@
+import { DataSchema, IDataField } from '@membranehq/sdk';
+import type { ComboBoxOptionsFactory, PopperRefElementType } from '../ComboBox/shared';
+export interface IDataBuilderField extends IDataField {
+    valueLocator?: string;
+    iconUri?: string;
+    level: number;
+    variablesSchema?: any;
+    exampleVariables?: any;
+    optionFactories: Array<ComboBoxOptionsFactory>;
+    isInSchema?: boolean;
+    isDeletable?: boolean;
+    hasSiblings?: boolean;
+    isLastChild?: boolean;
+    subFields?: IDataBuilderField[];
+    dynamicSchema?: DataSchema;
+    dynamicSchemaVariables?: any;
+}
+export interface IFieldComponent {
+    field: IDataBuilderField;
+    onChange?: (value: any) => void;
+    onKeyChange?: (key: string) => void;
+    onDelete?: () => void;
+    onEnter?: () => void;
+    refsToIgnoreClick?: PopperRefElementType[];
+}
+export declare function getFieldSchemaOptions(field: IDataBuilderField): DataSchema[];
+export declare function getFieldSchemaFromValue(field: IDataBuilderField): DataSchema | undefined;
+export declare function getDefaultFieldSchemaOption(field: IDataBuilderField): DataSchema | undefined;
+export declare function schemaFromValue(value: any, variablesSchema: any): {
+    type: any;
+} | {
+    type?: undefined;
+};
+export declare function extractFieldSubFields(field: IDataBuilderField): IDataBuilderField[];
+export declare function makeSubField(field: IDataBuilderField, overrides?: Partial<IDataBuilderField>): IDataBuilderField;
+export declare function fieldLabel(field: IDataBuilderField): string;
+export declare function isFieldVisible(field: any): boolean;
+export declare function getLevelForNestedFields(field: any): any;
+export declare function isObjectAllowedAdditionalProperties(field: IDataBuilderField): boolean;
+export declare function getFieldValueProps(field: IDataBuilderField): {
+    isEmpty: boolean;
+    isRequired: boolean | undefined;
+};
+export declare function schemaIsScalarArray(schema: any): boolean;
+export declare function isRootField(field: IDataBuilderField): boolean;
+export declare const DEFAULT_FIELD_KEY = "";

package/dist/types/components/DataBuilder/field-context.d.ts

@@ -0,0 +1,18 @@
+import { DataSchema } from '@membranehq/sdk';
+import { IDataBuilderField } from './data-field';
+export default function useDataBuilderField(): DataBuilderFieldContextInterface;
+interface DataBuilderFieldContextInterface {
+    field: IDataBuilderField;
+    localSchema: DataSchema;
+    setLocalSchema: (schema: DataSchema) => void;
+    resetLocalSchema: () => void;
+    localSchemaChangedManually: boolean;
+    setLocalSchemaChangedManually: (changed: boolean) => void;
+    autoOpen?: boolean;
+    setAutoOpen: (autoOpen: boolean) => void;
+}
+export declare const DataBuilderFieldProvider: ({ field, children }: {
+    field: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/DataBuilder/hooks.d.ts

@@ -0,0 +1,2 @@
+export declare function useDataBuilderFieldCanUseVarFromVariables(): boolean;
+export declare function usIsFieldFrozen(): boolean;

package/dist/types/components/DataBuilder/index.d.ts

@@ -0,0 +1,17 @@
+import { DataSchema } from '@membranehq/sdk';
+import { IDataBuilderField } from './data-field';
+import { ComboBoxOptionsFactory } from '../ComboBox/shared';
+export { FieldDescription } from './FieldDescription';
+export declare function makeDataField({ key, schema: inputSchema, value, optionFactories, variablesSchema, exampleVariables, iconUri, valueLocator, level, resolveDynamicSchema, }: {
+    key?: string;
+    schema?: DataSchema | undefined;
+    value?: any;
+    valueLabel?: string;
+    optionFactories?: ComboBoxOptionsFactory[];
+    variablesSchema?: any;
+    exampleVariables?: any;
+    iconUri?: string;
+    valueLocator?: string;
+    level?: number;
+    resolveDynamicSchema?: boolean;
+}): IDataBuilderField;

package/dist/types/components/DataBuilder/stories/DataBuilder.test-formulas.helpers.d.ts

@@ -0,0 +1,12 @@
+import { DataBuilderFormulaType } from '@membranehq/sdk';
+import { PlayFunctionContext } from 'storybook/internal/types';
+type ValidFormulaKey = `$${DataBuilderFormulaType}`;
+export declare function renderFormulaStory({ value: initialFormulaValue, additionalProps, }: {
+    value: Partial<Record<ValidFormulaKey, any>> | string;
+    additionalProps?: boolean;
+}): (args: any) => import("react/jsx-runtime").JSX.Element;
+export declare function playClickOnCombobox(context: PlayFunctionContext<any, any>, idx?: number): Promise<void>;
+export declare function playClickOnSaveAndClose(context: PlayFunctionContext<any, any>, idx?: number): Promise<void>;
+export declare function expectCorrectDropdownBackButtonTitle(context: PlayFunctionContext<any, any>, title: string): Promise<void>;
+export declare function expectOutputValueMatchObject(context: PlayFunctionContext<any, any>, obj: any): Promise<void>;
+export {};

package/dist/types/components/DataBuilder/types.d.ts

@@ -0,0 +1,25 @@
+import { DataSchema } from '@membranehq/sdk';
+import { IDataBuilderField } from './data-field';
+export declare enum DataBuilderDrilldownType {
+    LOOKUP = "lookup",
+    CASE = "case",
+    FIND_APP_RECORD_ID = "findAppRecordId",
+    FIND_EXTERNAL_RECORD_ID = "findExternalRecordId"
+}
+export interface IDataBuilderDrilldownStep {
+    type: DataBuilderDrilldownType;
+    field: IDataBuilderField;
+}
+export interface IDataBuilderContext {
+    topLevelField: IDataBuilderField | null;
+    isAdminMode?: boolean;
+    isReadOnly?: boolean;
+    showNullValueFields: boolean;
+    hideReadOnlyFields: boolean;
+    frozenFieldsLocators?: string[];
+    errorFieldsLocators?: string[];
+    editableVariablesSchemaLocators?: string[];
+    onAddVariable?: (locator: string, schema: DataSchema) => void;
+    collapsedDataBuilder?: boolean;
+    initialVisibleFieldCount: number;
+}

package/dist/types/components/DataBuilderUI/ActionBar.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from 'react';
+export declare const dataBuilderActionBarRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"button" | "root", import("../../styled-system/types").SlotRecipeVariantRecord<"button" | "root">>;
+export declare const ActionBar: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>> & {
+    DeleteButton: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>;
+};

package/dist/types/components/DataBuilderUI/Cell.d.ts

@@ -0,0 +1,94 @@
+import { HTMLAttributes } from 'react';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
+import { RecipeVariantProps } from '../../styled-system/css';
+interface CellProps {
+    icon?: SvgIconType;
+}
+export declare const dataBuilderCellRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"root", {
+    type: {
+        name: {
+            root: {
+                flexGrow: "0";
+                flexShrink: "0";
+                flexWrap: "nowrap";
+                alignSelf: "stretch";
+                minW: "40";
+            };
+        };
+        combobox: {
+            root: {
+                flexDir: "row";
+                flexWrap: "wrap";
+                justifyContent: "start";
+                alignItems: "center";
+                px: "0";
+                py: "0";
+            };
+        };
+        input: {
+            root: {
+                px: "2";
+                py: "2";
+                '& > input': {
+                    w: "full";
+                };
+            };
+        };
+        value: {
+            root: {
+                py: "2";
+            };
+        };
+        icon: {
+            root: {
+                flexGrow: "0";
+                flexShrink: "0";
+                flexWrap: "nowrap";
+                display: "flex";
+                alignItems: "center";
+                justifyContent: "center";
+                color: "neutral.10";
+                px: "2.5";
+                py: "2.5";
+                '& svg': {
+                    w: "3.5";
+                    h: "3.5";
+                };
+            };
+        };
+    };
+    disabled: {
+        true: {
+            root: {
+                pointerEvents: "none";
+                bg: "slate.1";
+            };
+        };
+        false: {};
+    };
+    span: {
+        shrink: {
+            root: {
+                flexGrow: "0";
+                flexShrink: "1";
+            };
+        };
+        grow: {
+            root: {
+                flexGrow: "1";
+            };
+        };
+    };
+}>;
+type CellVariants = RecipeVariantProps<typeof dataBuilderCellRecipe>;
+export declare const Cell: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & CellProps & {
+    type?: "value" | "name" | "input" | "combobox" | "icon" | undefined;
+    disabled?: boolean | undefined;
+    span?: "grow" | "shrink" | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare const dataBuilderCellButtonRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"root", import("../../styled-system/types").SlotRecipeVariantRecord<"root">>;
+export declare const CellButton: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & CellProps & {} & {
+    type?: Extract<NonNullable<CellVariants>["type"], "icon">;
+    disabled?: NonNullable<CellVariants>["disabled"];
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/types/components/DataBuilderUI/FieldControlPanel/index.d.ts

@@ -0,0 +1,24 @@
+import { ButtonHTMLAttributes, PropsWithChildren } from 'react';
+export declare const fieldControlPanelRecipe: import("../../../styled-system/types").SlotRecipeRuntimeFn<"button" | "group" | "root" | "delimiter", {
+    noWrap: {
+        true: {
+            root: {
+                flexWrap: "nowrap";
+            };
+        };
+        false: {};
+    };
+}>;
+declare function FieldControlPanelRoot({ children, noWrap }: PropsWithChildren<{
+    noWrap?: boolean;
+}>): import("react/jsx-runtime").JSX.Element;
+declare function FieldControlPanelDelimiter({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+declare function FieldControlButtonGroup({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export declare const FieldControlPanel: typeof FieldControlPanelRoot & {
+    Delimiter: typeof FieldControlPanelDelimiter;
+    ButtonGroup: typeof FieldControlButtonGroup;
+    Button: import("react").ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+        isNested?: boolean;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/types/components/DataBuilderUI/NestedLevel.d.ts

@@ -0,0 +1,4 @@
+export declare function NestedLevel({ level, children }: {
+    level?: number;
+    children: React.ReactNode;
+}): string | number | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/types/components/DataBuilderUI/Row.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes } from 'react';
+import { RecipeVariantProps } from '../../styled-system/css';
+export declare const dataBuilderRowRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"row", {
+    span: {
+        short: {
+            row: {
+                width: "fit-content";
+            };
+        };
+        default: {};
+    };
+}>;
+type RowVariants = RecipeVariantProps<typeof dataBuilderRowRecipe>;
+export declare function Row({ children, className, span, ...rest }: HTMLAttributes<HTMLDivElement> & RowVariants): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/DataBuilderUI/Title.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes, ReactNode } from 'react';
+interface TitleProps extends HTMLAttributes<HTMLDivElement> {
+    hasError?: boolean;
+    hasNameConflict?: boolean;
+    required?: boolean;
+    hasValue?: boolean;
+    leftSlot?: ReactNode;
+    typeSelectorSlot?: ReactNode;
+    rightSlot?: ReactNode;
+    childrenWrap?: boolean;
+}
+export declare const dataBuilderTitleRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"title" | "root" | "left-side" | "right-side" | "title-wrap", import("../../styled-system/types").SlotRecipeVariantRecord<"title" | "root" | "left-side" | "right-side" | "title-wrap">>;
+export declare const Title: import("react").ForwardRefExoticComponent<TitleProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const dotRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"dot" | "root", import("../../styled-system/types").SlotRecipeVariantRecord<"dot" | "root">>;
+export declare const Dot: import("react").ForwardRefExoticComponent<{
+    reason: string;
+} & HTMLAttributes<HTMLSpanElement> & import("react").RefAttributes<HTMLSpanElement>>;
+export {};

package/dist/types/components/DataBuilderUI/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FieldControlPanel';
+export * from './ActionBar';
+export * from './Cell';
+export * from './NestedLevel';
+export * from './Row';
+export * from './Title';

package/dist/types/components/DataInput/index.d.ts

@@ -0,0 +1,15 @@
+import { DataSchema } from '@membranehq/sdk';
+export declare function DataInput({ schema, variablesSchema, value, onChange, readOnly, editableVariablesSchemaLocators, onAddVariable, isAdminMode, errorFieldsLocators, frozenFieldsLocators, showNullValueFields, hideReadOnlyFields, }: {
+    schema?: DataSchema;
+    variablesSchema?: DataSchema;
+    value: any;
+    readOnly?: boolean;
+    onChange: (value: any) => void;
+    editableVariablesSchemaLocators?: string[];
+    onAddVariable?: (locator: string, schema: any) => void;
+    isAdminMode?: boolean;
+    errorFieldsLocators?: string[];
+    frozenFieldsLocators?: string[];
+    showNullValueFields?: boolean;
+    hideReadOnlyFields?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DataInput/useResolvedDataSchema.d.ts

@@ -0,0 +1,5 @@
+import { DataSchema } from '@membranehq/sdk';
+export declare function useDynamicDataSchema(schema: DataSchema | undefined, value: unknown): {
+    schema: DataSchema | undefined;
+    error: Error | undefined;
+};

package/dist/types/components/DataLinks/data-link-tables-option-factory.d.ts

@@ -0,0 +1,16 @@
+import { IntegrationAppClient } from '@membranehq/sdk';
+import { ComboBoxOption, ComboBoxOptionsFactory } from '../ComboBox/shared';
+export interface IDataLinkTablesOptionsFactoryArgs {
+    client: IntegrationAppClient;
+    connectionId: string;
+    isAdminMode: boolean;
+}
+export declare class DataLinkTablesOptionsFactory implements ComboBoxOptionsFactory {
+    private args;
+    constructor(args: IDataLinkTablesOptionsFactoryArgs);
+    getOptions({ input }: {
+        input: any;
+    }): Promise<ComboBoxOption[]>;
+    private cachedOptions;
+    private getCachedOptions;
+}

package/dist/types/components/DataLinks/index.d.ts

@@ -0,0 +1 @@
+export * from './data-link-tables-option-factory';

package/dist/types/components/DropdownUI/BackButton.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+export declare const BackButton: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & {
+    current?: boolean;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/DropdownUI/ClearSearchButton.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const ClearSearchButton: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/DropdownUI/Content.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const Content: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/ErrorHeading.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+export declare const ErrorHeading: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    text?: string;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/InfoHeading.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+export declare const InfoHeading: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    text?: string;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/Item.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from 'react';
+export declare const Item: import("react").ForwardRefExoticComponent<{
+    className?: string;
+    current?: boolean;
+} & HTMLAttributes<HTMLDivElement> & {
+    children?: import("react").ReactNode | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/ItemHint.d.ts

@@ -0,0 +1,4 @@
+export declare function ItemHint({ value, prefix }: {
+    value?: string;
+    prefix?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/DropdownUI/ItemIcon.d.ts

@@ -0,0 +1,10 @@
+import { ImgHTMLAttributes, SVGAttributes } from 'react';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
+type SvgIconProps = SVGAttributes<SVGElement> & {
+    type: SvgIconType;
+};
+type ImgIconProps = ImgHTMLAttributes<HTMLImageElement>;
+export declare function ItemIcon({ className, framed, ...props }: (SvgIconProps | ImgIconProps) & {
+    framed?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/DropdownUI/ItemNestingIndicator.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+export declare function ItemNestingIndicator({ count, children }: PropsWithChildren<{
+    count?: number;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownUI/ItemTitle.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare function ItemTitle({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownUI/List.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const List: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/ListHeader.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const ListHeader: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/types/components/DropdownUI/LoadingItem.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+export declare const LoadingItem: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    delay?: number;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/NoOptionsHeading.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+export declare const NoOptionsHeading: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    text?: string;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/Panel.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const Panel: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/PopoverContainer.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const PopoverContainer: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownUI/Search.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from 'react';
+export declare const Search: import("react").ForwardRefExoticComponent<{
+    value?: string;
+    onChange?: (value: string) => void;
+    autoFocus?: boolean;
+    placeholder?: HTMLInputElement["placeholder"];
+} & Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const SearchDivider: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownUI/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DROPDOWN_NAVIGATOR_ID = "dropdown-navigator";
+export declare const DROPDOWN_SEARCH_INPUT_ID = "dropdown-search-input";