@integration-app/react 2.0.3-beta.3 → 2.0.4-beta.0

package/dist/types/_modules/react-use-promise.d.ts

@@ -1,2 +1,3 @@
-declare const usePromise: any;
+import usePromiseImport from 'react-use-promise';
+declare const usePromise: typeof usePromiseImport;
 export default usePromise;

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { SvgIconType } from '../SvgIcon';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
 import { ButtonProps, GenericButtonProps, IconButtonProps } from './Button.types';
 export declare const GenericButton: import("react").ForwardRefExoticComponent<GenericButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
 export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/ComboBox/{index.d.ts → ComboBox.d.ts}

@@ -1,7 +1,2 @@
 import { ComboBoxProps } from './types';
-export type * from './types';
-export * from './value-spec';
-export * from './options-factories';
-export * from './context';
-export * from './Value';
 export declare function ComboBox({ value, schema, valueSpec, variablesSchema, variablesOnly, options, optionFactories, onChange, valueComponent, placeholder, isRequired, disabled, className, hideSearch, autoOpen, onOpen, onClose, topDropdownPanelComponent, refsToIgnoreClick, }: ComboBoxProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/ActiveCategoryContent.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../types';
+export declare function ActiveCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/CustomValue.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../components/ComboBox/types';
+export declare function CustomValueCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/Formulas/DropdownPanelFormulaConfig.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../../components/ComboBox/types';
+export declare function DropdownPanelFormulaConfig({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/ComboBox/Dropdown/Categories/Formulas/index.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../../components/ComboBox/types';
+export declare function FormulasCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/Lookup.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../components/ComboBox/types';
+export declare function LookupCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/ComboBox/Dropdown/Categories/LookupOptions/ParametersPanel.d.ts

@@ -0,0 +1,7 @@
+import { DataSchema } from '@integration-app/sdk';
+export declare function ParametersPanel({ onChange, schema, value, className, }: {
+    onChange: (value: unknown) => void;
+    schema?: DataSchema;
+    value: any;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/{Tabs → Categories}/LookupOptions/UiComponents.d.ts

@@ -1,9 +1,13 @@
 import { PropsWithChildren } from 'react';
-import { ButtonProps } from '../../../../../components/Button';
-export declare function PanelHeader({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+import { ButtonProps } from '../../../../../ui-kit/button';
+export declare function PanelHeader({ title, actions, }: {
+    title: string;
+    actions?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function PanelHeaderButton({ children, ...props }: PropsWithChildren<ButtonProps>): import("react/jsx-runtime").JSX.Element;
 export declare function ParametersList({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
 export declare function Parameter({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export declare function NoParameters(): import("react/jsx-runtime").JSX.Element;
 export declare function ParameterText({ title, value, }: {
     title: string;
     value?: string;

package/dist/types/components/ComboBox/Dropdown/Categories/LookupOptions/index.d.ts

@@ -0,0 +1,8 @@
+import { FnOnValueChangeType } from '../../../types';
+export declare function LookupOptionsCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function OptionsParametersRequiredAlert(): import("react/jsx-runtime").JSX.Element;
+export declare function AdditionalMessageAlert({ text }: {
+    text: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/Options.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../components/ComboBox/types';
+export declare function OptionsCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/Root.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../components/ComboBox/types';
+export declare function RootCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/Variables.d.ts

@@ -0,0 +1,4 @@
+import { FnOnValueChangeType } from '../../../../components/ComboBox/types';
+export declare function VariablesCategoryContent({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Categories/getLookupCollection.d.ts

@@ -0,0 +1,7 @@
+import { DataSchema, DataCollectionSpec, IntegrationAppClient } from '@integration-app/sdk';
+export declare function getLookupCollection({ schema, client, connectionId, integrationId, }: {
+    schema: DataSchema;
+    client: IntegrationAppClient;
+    connectionId: string;
+    integrationId: string;
+}): Promise<DataCollectionSpec | undefined>;

package/dist/types/components/ComboBox/Dropdown/DrillUpButton.d.ts

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

package/dist/types/components/ComboBox/Dropdown/Dropdown.d.ts

@@ -1,12 +1,9 @@
 /// <reference types="react" />
-import { DropdownUIPopperProps } from '../../../components/ComboBoxElements/Popper';
 import { ComboBoxDropdownProps, FnOnValueChangeType } from '../types';
 export interface DropdownProps {
-    referenceElement: DropdownUIPopperProps['referenceElement'];
     topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
-    onSelect: FnOnValueChangeType;
-    onClose: () => void;
+    onOptionSelect: FnOnValueChangeType;
     autoFocusOnSearch?: boolean;
+    children?: React.ReactNode;
 }
-export declare const Dropdown: import("react").ForwardRefExoticComponent<DropdownProps & import("react").RefAttributes<HTMLDivElement>>;
-export declare function DropdownTabs(): import("react/jsx-runtime").JSX.Element | null;
+export declare function Dropdown({ topDropdownPanelComponent, autoFocusOnSearch, onOptionSelect, children, }: DropdownProps): string | number | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/types/components/ComboBox/Dropdown/Option.d.ts

@@ -1,6 +1,6 @@
-import { ComboBoxOptionType } from '../types';
-export default function ComboBoxOption({ option, selected, current, onSelect, }: {
-    option: ComboBoxOptionType;
+import { ComboBoxOption } from '../types';
+export default function DropdownOption({ option, selected, current, onSelect, }: {
+    option: ComboBoxOption;
     onSelect: () => void;
     selected?: boolean;
     current?: boolean;

package/dist/types/components/ComboBox/Dropdown/OptionsList.d.ts

@@ -1,4 +1,4 @@
 import { FnOnValueChangeType } from '../types';
-export declare function OptionsList({ onSelect }: {
-    onSelect: FnOnValueChangeType;
+export declare function OptionsList({ onOptionSelect, }: {
+    onOptionSelect: FnOnValueChangeType;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/categoryContentMapping.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { SvgIconType } from '../../../components/SvgIcon/svg-icon-type';
+import { DropdownCategoryType, FnOnValueChangeType } from '../types';
+type RenderCategoryType = Record<DropdownCategoryType, {
+    title: string;
+    icon?: SvgIconType;
+    hideSearchInput?: boolean;
+    hasConfigUI?: boolean;
+}>;
+export declare const renderCategories: RenderCategoryType;
+export declare const CATEGORY_COMPONENTS: Record<DropdownCategoryType, React.FC<{
+    onOptionSelect: FnOnValueChangeType;
+    onConfigSelect?: (category: DropdownCategoryType) => void;
+}>>;
+export {};

package/dist/types/components/ComboBox/Dropdown/index.d.ts

@@ -1,4 +1 @@
-import { Dropdown, DropdownTabs } from './Dropdown';
-import { SearchInput as DropdownSearch } from './SearchInput';
-import { ActiveTab as DropdownActiveTab } from './ActiveTab';
-export { Dropdown, DropdownTabs, DropdownActiveTab, DropdownSearch };
+export { Dropdown } from './Dropdown';

package/dist/types/components/ComboBox/DropdownPopover/helpers.d.ts

@@ -0,0 +1 @@
+export declare const useMountDropdownReposition: () => void;

package/dist/types/components/ComboBox/DropdownPopover/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare function DropdownPopoverProvider({ children, }: {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownPopoverContent({ children, }: {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownAnchor({ children }: {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Edit/TextInput.d.ts

@@ -1,2 +1,2 @@
-import { ComboBoxComponentProps } from '../types';
+import { ComboBoxComponentProps } from '../../../components/ComboBox/types';
 export declare function TextInput({ placeholder, className, onChange, disabled, required, }: ComboBoxComponentProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Value/ComboBoxValue.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ComboBoxValueProps } from '../types';
+export declare const ComboBoxValue: import("react").ForwardRefExoticComponent<ComboBoxValueProps & import("react").RefAttributes<HTMLDivElement | HTMLSpanElement>>;

package/dist/types/components/ComboBox/Value/Formula.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { FormulaProps } from '../../DataBuilder/Formula';
+import { FormulaProps } from '../../../components/DataBuilder/Formula/types';
 export interface ComboBoxFormulaValueProps extends Omit<FormulaProps<any>, 'formula'> {
     value: any;
     className?: string;

package/dist/types/components/ComboBox/Value/Schema.d.ts

@@ -1,4 +1,3 @@
 /// <reference types="react" />
 import { ComboBoxSchemaValueProps } from '../types';
 export declare const ComboBoxSchemaValue: import("react").ForwardRefExoticComponent<ComboBoxSchemaValueProps & import("react").RefAttributes<HTMLSpanElement>>;
-export declare function isDefinedValue(value: any): boolean;

package/dist/types/components/ComboBox/Value/index.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="react" />
-import { ComboBoxValueProps } from '../types';
 export * from './Formula';
 export * from './Schema';
-export declare const ComboBoxValue: import("react").ForwardRefExoticComponent<ComboBoxValueProps & import("react").RefAttributes<HTMLDivElement | HTMLSpanElement>>;
+export * from './ComboBoxValue';

package/dist/types/components/ComboBox/Value/isDefinedValue.d.ts

@@ -0,0 +1 @@
+export declare function isDefinedValue(value: any): boolean;

package/dist/types/components/ComboBox/context/combobox-context.d.ts

@@ -5,6 +5,7 @@ interface ComboBoxContextProps extends ComboBoxOptionsProps {
     openDropdown: () => void;
     closeDropdown: () => void;
     topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
+    scopedComboboxId: string;
 }
 export declare const ComboBoxProvider: ({ value, schema, valueSpec, variablesSchema, options, optionFactories, refsToIgnoreClick, onDropdownOpen, onDropdownClose, autoOpen, topDropdownPanelComponent, children, }: React.PropsWithChildren<ComboBoxOptionsProps & ComboBoxDropdownProps>) => import("react/jsx-runtime").JSX.Element;
 export declare function useComboBox(): ComboBoxContextProps;

package/dist/types/components/ComboBox/context/combobox-dropdown-context.d.ts

@@ -1,12 +1,15 @@
 import { PropsWithChildren } from 'react';
-import { ComboBoxOptionType, ComboBoxTabType, OptionsStateType } from '../types';
+import usePromise from '../../../_modules/react-use-promise';
+import { ComboBoxOption, DropdownCategoryType } from '../types';
 interface ComboBoxDropdownContextProps {
-    availableTabs: ComboBoxTabType[] | null;
-    activeTab: ComboBoxTabType | null;
-    setActiveTab: (mode: ComboBoxTabType | null) => void;
-    resetActiveTab: () => void;
-    isOptionSelected: (option: ComboBoxOptionType) => boolean;
-    generateOptions: (inputValue: string, drilldownStack: any[]) => [ComboBoxOptionType[], Error?, OptionsStateType?];
+    availableCategories: DropdownCategoryType[] | null;
+    activeCategory: DropdownCategoryType;
+    drillDown: (option: ComboBoxOption) => void;
+    drillUp: () => void;
+    isOptionSelected: (option: ComboBoxOption) => boolean;
+    optionsPayload: ReturnType<typeof usePromise<ComboBoxOption[]>>;
+    canUseParentInputSearchValue: boolean;
+    drillDownStackTop?: ComboBoxOption;
 }
 export declare const ComboBoxDropdownContextProvider: ({ children, }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
 export declare function useComboBoxDropdownContext(): ComboBoxDropdownContextProps;

package/dist/types/components/ComboBox/context/combobox-dropdown-search.d.ts

@@ -4,13 +4,11 @@ interface ComboBoxSearchContextProps {
     hideSearch: boolean;
     searchValue: string;
     setSearchValue: (value: string) => void;
-    drillDownDepth: number;
-    setDrillDownDepth: (depth: number) => void;
     searchSource: SearchSource;
     setSearchSource: (target: SearchSource) => void;
 }
 export declare const ComboBoxDropdownSearchProvider: ({ children, hideSearch, }: PropsWithChildren<{
-    hideSearch?: boolean | undefined;
+    hideSearch?: boolean;
 }>) => import("react/jsx-runtime").JSX.Element;
 export declare function useComboBoxDropdownSearchContext(): ComboBoxSearchContextProps;
 export {};

package/dist/types/components/ComboBox/context/helpers.d.ts

@@ -1,15 +1,16 @@
 import { DataSchema, IntegrationAppClient } from '@integration-app/sdk';
-import { ComboBoxOptionsFactoryInterface } from '../options-factories';
-import { ComboBoxOptionType, ComboBoxTabType, ValueDataType } from '../types';
-export declare function getAvailableTabs({ schema, options, optionFactories, variablesOnly, hasVariables, client, connectionId, integrationId, }: {
+import { ComboBoxOptionsFactory } from '../options-factories';
+import { ComboBoxOption, DropdownCategoryType, ValueDataType } from '../types';
+export declare function getAvailableRootCategories({ schema, options, optionFactories, variablesOnly, hasVariables, client, connectionId, integrationId, }: {
     schema: DataSchema | undefined;
-    options: ComboBoxOptionType[] | undefined;
-    optionFactories: ComboBoxOptionsFactoryInterface[] | undefined;
+    options: ComboBoxOption[] | undefined;
+    optionFactories: ComboBoxOptionsFactory[] | undefined;
     variablesOnly: boolean | undefined;
     hasVariables: boolean;
     client: IntegrationAppClient;
     connectionId: string;
     integrationId: string;
-}): Promise<ComboBoxTabType[] | null>;
-export declare function getCurrentTab(availableTabs: ComboBoxTabType[], possibleCurrentTab: ComboBoxTabType | null, value: string): ComboBoxTabType;
-export declare function canUserEnterValueFromKeyboard(schema: DataSchema | undefined, options: ComboBoxOptionType[] | undefined, optionFactories: ComboBoxOptionsFactoryInterface[], variablesOnly: boolean, value: ValueDataType): boolean;
+}): Promise<DropdownCategoryType[] | null>;
+export declare function getCurrentPath(availableCategories: DropdownCategoryType[], value: string): DropdownCategoryType[];
+export declare function getStackForPath(path: DropdownCategoryType[], value: string | object, getOptions: (searchValue: string, drillDownStack: ComboBoxOption[]) => Promise<ComboBoxOption[]>, stack: ComboBoxOption[], searchValue: string): Promise<ComboBoxOption[]>;
+export declare function canUserEnterValueFromKeyboard(schema: DataSchema | undefined, options: ComboBoxOption[] | undefined, optionFactories: ComboBoxOptionsFactory[], variablesOnly: boolean, value: ValueDataType): boolean;

package/dist/types/components/ComboBox/options-factories/boolean.d.ts

@@ -1,6 +1,6 @@
-import { ComboBoxOptionType } from '../types';
-import { ComboBoxOptionsFactoryInterface } from '.';
-export declare class BooleanOptionsFactory implements ComboBoxOptionsFactoryInterface {
-    getOptions(): Promise<ComboBoxOptionType[]>;
-    getOptionsSync(): ComboBoxOptionType[];
+import { ComboBoxOption } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
+export declare class BooleanOptionsFactory implements ComboBoxOptionsFactory {
+    getOptions({}: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync(): ComboBoxOption[];
 }

package/dist/types/components/ComboBox/options-factories/constant.d.ts

@@ -1,11 +1,8 @@
-import { ComboBoxOptionType } from '../types';
-export declare class ConstantOptionFactory {
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
+import { ComboBoxOption } from '../types';
+export declare class ConstantOptionFactory implements ComboBoxOptionsFactory {
     private options;
-    constructor(options: ComboBoxOptionType[]);
-    getOptions({ input }: {
-        input: any;
-    }): Promise<ComboBoxOptionType[]>;
-    getOptionsSync({ input }: {
-        input: any;
-    }): ComboBoxOptionType[];
+    constructor(options: ComboBoxOption[]);
+    getOptions({ input, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync({ input }: GetOptionsArgs): ComboBoxOption[];
 }

package/dist/types/components/ComboBox/options-factories/custom-field.d.ts

@@ -1,13 +1,10 @@
-import { ComboBoxOptionType, ValueDataType } from '../types';
-import { ComboBoxOptionsFactoryInterface } from '.';
+import { ComboBoxOption, ValueDataType } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
 export declare const CUSTOM_OBJECT_VALUE: {};
 export declare const CUSTOM_OBJECT_VALUE_LABEL = "Object With Custom Fields";
 export declare const CUSTOM_ARRAY_VALUE: never[];
 export declare const CUSTOM_ARRAY_VALUE_LABEL = "List With Custom Items";
-export declare class CustomFieldOptionsFactory implements ComboBoxOptionsFactoryInterface {
-    getOptions({ spec, input }: {
-        spec: any;
-        input: any;
-    }): Promise<ComboBoxOptionType[]>;
+export declare class CustomFieldOptionsFactory implements ComboBoxOptionsFactory {
+    getOptions({ spec, input, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
 }
 export declare function isCustomFieldValue(value: ValueDataType): boolean;

package/dist/types/components/ComboBox/options-factories/enum.d.ts

@@ -1,17 +1,15 @@
-import { ComboBoxOptionType } from '../types';
-import { ComboBoxOptionsFactoryInterface } from '.';
+import { ComboBoxOption } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
 interface IEnumOptionsFactoryParameters {
     schema: any;
     iconUri?: string;
 }
-export declare class EnumOptionFactory implements ComboBoxOptionsFactoryInterface {
+export declare class EnumOptionFactory implements ComboBoxOptionsFactory {
     private params;
     constructor(params: IEnumOptionsFactoryParameters);
-    getOptions({ input }: {
-        input: any;
-    }): Promise<ComboBoxOptionType[]>;
+    getOptions({ input, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
     getOptionsSync({ input }: {
         input: any;
-    }): ComboBoxOptionType[];
+    }): ComboBoxOption[];
 }
 export {};

package/dist/types/components/ComboBox/options-factories/formula.d.ts

@@ -0,0 +1,8 @@
+import { ComboBoxOptionsFactory } from './index';
+import { ComboBoxOption } from '../types';
+export declare class FormulaListOptionsFactory implements ComboBoxOptionsFactory {
+    getOptions({ input, spec }: {
+        input: any;
+        spec: any;
+    }): Promise<ComboBoxOption[]>;
+}

package/dist/types/components/ComboBox/options-factories/generate-schema-options.d.ts

@@ -0,0 +1,16 @@
+import { DataLocator, DataSchema } from '@integration-app/sdk';
+import { ComboBoxOption } from '../types';
+import { ValueSpecType } from '../value-spec';
+export declare function getOptionsForSchema({ schema, locator, valueSpec, showIcons, skipNameComponentsPrefix, ignorePrefix, nameComponentsByLocator, schemaByLocator, exampleVariables, expandObject, editableSchemaLocators, }: {
+    schema: DataSchema;
+    locator: DataLocator;
+    valueSpec?: ValueSpecType;
+    showIcons?: boolean;
+    skipNameComponentsPrefix?: Array<string>;
+    ignorePrefix?: boolean;
+    nameComponentsByLocator?: any;
+    schemaByLocator?: any;
+    exampleVariables?: any;
+    expandObject?: boolean;
+    editableSchemaLocators?: string[];
+}): ComboBoxOption[];

package/dist/types/components/ComboBox/options-factories/index.d.ts

@@ -1,18 +1,9 @@
-import { ComboBoxOptionType } from '../types';
-import { ValueSpecType } from '../value-spec';
-export * from './base';
+export * from './utils';
 export * from './boolean';
 export * from './constant';
 export * from './custom-field';
 export * from './enum';
 export * from './object-fields';
 export * from './reference-records';
-export * from './reference-udm';
-export * from './schema';
-export interface ComboBoxOptionsFactoryInterface {
-    getOptions({ input, spec, }: {
-        input: string;
-        spec: ValueSpecType;
-    }): Promise<ComboBoxOptionType[]>;
-}
-export declare function getSchemaHint(schema: any): any;
+export * from './variable';
+export * from './types';

package/dist/types/components/ComboBox/options-factories/object-fields.d.ts

@@ -1,6 +1,6 @@
 import { DataLocator } from '@integration-app/sdk';
-import { ComboBoxOptionType } from '../types';
-import { ComboBoxOptionsFactoryInterface } from '.';
+import { ComboBoxOption } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
 interface IObjectFieldsOptionFactoryParameters {
     name?: string;
     schema: any;
@@ -9,16 +9,10 @@ interface IObjectFieldsOptionFactoryParameters {
     isSection?: boolean;
     editableSchemaLocators?: string[];
 }
-export declare class ObjectFieldsOptionFactory implements ComboBoxOptionsFactoryInterface {
+export declare class ObjectFieldsOptionFactory implements ComboBoxOptionsFactory {
     private parameters;
     constructor(parameters: IObjectFieldsOptionFactoryParameters);
-    getOptions({ input, spec }: {
-        input: any;
-        spec: any;
-    }): Promise<ComboBoxOptionType[]>;
-    getOptionsSync({ input, spec }: {
-        input: any;
-        spec: any;
-    }): ComboBoxOptionType[];
+    getOptions({ input, spec, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync({ input, spec }: GetOptionsArgs): ComboBoxOption[];
 }
 export {};

package/dist/types/components/ComboBox/options-factories/reference-records.d.ts

@@ -1,17 +1,13 @@
-import { ComboBoxOptionType } from '../types';
-import { ComboBoxOptionsFactoryInterface } from '.';
+import { ComboBoxOption } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
 interface IReferenceRecordsOptionsFactoryParameters {
     schema: any;
     iconUri?: string;
 }
-export declare class ReferenceRecordsOptionsFactory implements ComboBoxOptionsFactoryInterface {
+export declare class ReferenceRecordsOptionsFactory implements ComboBoxOptionsFactory {
     private params;
     constructor(params: IReferenceRecordsOptionsFactoryParameters);
-    getOptions({ input }: {
-        input: any;
-    }): Promise<ComboBoxOptionType[]>;
-    getOptionsSync({ input }: {
-        input: any;
-    }): ComboBoxOptionType[];
+    getOptions({ input, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync({ input }: GetOptionsArgs): ComboBoxOption[];
 }
 export {};

package/dist/types/components/ComboBox/options-factories/root.d.ts

@@ -0,0 +1,9 @@
+import { ComboBoxOption, DropdownCategoryType } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './index';
+export declare class RootOptionFactory implements ComboBoxOptionsFactory {
+    private readonly categories;
+    constructor(categories: DropdownCategoryType[] | null);
+    getOptions({ input, spec, variablesSchema, editableVariablesSchemaLocators, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync({ input, variablesSchema, editableVariablesSchemaLocators, }: GetOptionsArgs): ComboBoxOption[];
+    private getChildFactoryForCategory;
+}

package/dist/types/components/ComboBox/options-factories/types.d.ts

@@ -0,0 +1,13 @@
+import { ComboBoxOption } from '../types';
+import { ValueSpecType } from '../value-spec';
+import { DataSchema } from '@integration-app/sdk';
+import { IDataBuilderContext } from '../../../components/DataBuilder/types';
+export type GetOptionsArgs = {
+    input: string;
+    spec?: ValueSpecType;
+    variablesSchema?: DataSchema;
+    editableVariablesSchemaLocators?: IDataBuilderContext['editableVariablesSchemaLocators'];
+};
+export interface ComboBoxOptionsFactory {
+    getOptions(args: GetOptionsArgs): Promise<ComboBoxOption[]>;
+}

package/dist/types/components/ComboBox/options-factories/utils.d.ts

@@ -0,0 +1,2 @@
+import { ComboBoxOption } from '../types';
+export declare function filterOptionsByLabel(options: ComboBoxOption[], searchString: string, fuzzy?: boolean): ComboBoxOption[];

package/dist/types/components/ComboBox/options-factories/variable.d.ts

@@ -0,0 +1,17 @@
+import { DataLocator } from '@integration-app/sdk';
+import { ComboBoxOption } from '../types';
+import { ComboBoxOptionsFactory, GetOptionsArgs } from './types';
+interface IVariableOptionFactoryParameters {
+    schema: any;
+    locator?: DataLocator;
+    isSection?: boolean;
+    exampleVariables?: any;
+    editableSchemaLocators?: string[];
+}
+export declare class VariableOptionFactory implements ComboBoxOptionsFactory {
+    private parameters;
+    constructor(parameters: IVariableOptionFactoryParameters);
+    getOptions({ input, spec, }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+    getOptionsSync({ input, spec }: GetOptionsArgs): ComboBoxOption[];
+}
+export {};

package/dist/types/components/ComboBox/tests/presets.d.ts

@@ -1,4 +1,4 @@
 import { DataSchema } from '@integration-app/sdk';
-import { ComboBoxOptionType } from '../types';
-export declare const mockOptions: ComboBoxOptionType[];
+import { ComboBoxOption } from '../types';
+export declare const mockOptions: ComboBoxOption[];
 export declare const mockVariablesSchema: DataSchema;

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

@@ -1,7 +1,7 @@
 import { MutableRefObject, ReactNode } from 'react';
 import { DataLocator, DataSchema } from '@integration-app/sdk';
-import { SvgIconType } from '../SvgIcon';
-import { ComboBoxOptionsFactoryInterface } from './options-factories';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
+import { ComboBoxOptionsFactory } from './options-factories/types';
 import { ValueSpecType } from './value-spec';
 export type ValueDataType = any;
 type VariablesSchemaType = any;
@@ -17,8 +17,8 @@ export interface ComboBoxOptionsProps {
     valueSpec?: ValueSpecType;
     variablesSchema?: VariablesSchemaType;
     variablesOnly?: boolean;
-    options?: ComboBoxOptionType[];
-    optionFactories?: Array<ComboBoxOptionsFactoryInterface>;
+    options?: ComboBoxOption[];
+    optionFactories?: Array<ComboBoxOptionsFactory>;
     refsToIgnoreClick?: PopperRefElementType[];
 }
 export interface ComboBoxProps extends ComboBoxOptionsProps {
@@ -49,19 +49,16 @@ export interface ComboBoxDropdownProps {
     onDropdownClose?: FnCloseEditModeType;
     topDropdownPanelComponent?: JSX.Element;
 }
-export interface ComboBoxOptionType {
+export interface ComboBoxOption {
     value?: ValueDataType;
     label: ReactNode;
     searchLabel?: string;
-    hint?: ReactNode;
-    isCustomValue?: boolean;
+    childrenCount?: number;
     isSection?: boolean;
-    isHighlighted?: boolean;
-    drilldown?: DataLocator;
-    drilldownOptionFactories?: ComboBoxOptionsFactoryInterface[];
-    drillup?: boolean;
+    drillDown?: DataLocator;
+    drillDownOptionFactory?: ComboBoxOptionsFactory;
     addVariable?: string;
-    group?: string;
+    childCategory?: DropdownCategoryType;
     iconUri?: string;
     iconType?: SvgIconType;
 }
@@ -92,13 +89,14 @@ export interface ComboBoxSchemaValueProps extends Omit<ComboBoxTagProps, 'childr
     schema: DataSchema | undefined;
     variablesSchema: DataSchema | undefined;
 }
-export declare enum ComboBoxTabType {
+export declare enum DropdownCategoryType {
+    ROOT = "root",
     VARIABLE = "variable",
     OPTIONS = "options",
     FORMULA = "formula",
+    FORMULA_CONFIG = "formula_config",
     CUSTOM = "custom",
     LOOKUP_OPTIONS = "lookup_options",
-    SELECT_FROM_COLLECTION_DYNAMICALLY = "select_from_collection_dynamically",
     SELECT_FROM_UDM_DYNAMICALLY = "select_from_udm_dynamically"
 }
 export {};