@integration-app/react 2.0.3-beta.1 → 2.0.3-beta.2

package/dist/types/__mocks__/axios.d.ts

@@ -0,0 +1,4 @@
+export const axiosMock: MockAdapter;
+export default axios;
+import MockAdapter from 'axios-mock-adapter';
+import axios from 'axios';

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

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

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export declare function AdvancedOptions({ title, openByDefault, children, }: {
+    title?: string;
+    openByDefault?: boolean;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { SvgIconType } from '../SvgIcon';
+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>>;
+export declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare function ButtonSvgIcon({ type, className, size, position, }: {
+    type: SvgIconType;
+    className?: string;
+    size?: 'normal' | 'small';
+    position?: 'start' | 'end';
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,17 @@
+import { ButtonHTMLAttributes } from 'react';
+import { GenericTooltipProps } from '../Tooltip';
+export type ButtonVariantType = 'primary' | 'secondary' | 'outline' | 'text' | 'warning' | 'ajax';
+export type ButtonSizeType = 'small' | 'medium' | 'large';
+export interface GenericButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    loading?: boolean;
+    tooltip?: GenericTooltipProps['tooltip'];
+    tooltipProps?: Partial<Omit<GenericTooltipProps, 'tooltip' | 'children'>>;
+}
+export interface ButtonProps extends GenericButtonProps {
+    variant?: ButtonVariantType;
+    size?: ButtonSizeType;
+}
+export interface IconButtonProps extends Omit<ButtonProps, 'variant'> {
+    isActive?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './Button';
+export type { GenericButtonProps, ButtonProps } from './Button.types';

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

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

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

@@ -0,0 +1,12 @@
+/// <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;
+    autoFocusOnSearch?: boolean;
+}
+export declare const Dropdown: import("react").ForwardRefExoticComponent<DropdownProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare function DropdownTabs(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,7 @@
+import { ComboBoxOptionType } from '../types';
+export default function ComboBoxOption({ option, selected, current, onSelect, }: {
+    option: ComboBoxOptionType;
+    onSelect: () => void;
+    selected?: boolean;
+    current?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,6 @@
+export declare function SearchInput({ autoFocus }: {
+    autoFocus?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function DropdownSearchComponent({ autoFocus, }: {
+    autoFocus?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function CustomValueTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function FormulasTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { DataSchema, DataCollectionSpec } from '@integration-app/sdk';
+import { IntegrationAppClient } from '@integration-app/sdk';
+export declare function LookupTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element | null;
+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/Tabs/LookupOptions/OptionsList.d.ts

@@ -0,0 +1 @@
+export declare function OptionsParametersRequired(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export declare function ParametersPanel({ onChange, schema, value }: {
+    onChange: any;
+    schema: any;
+    value: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ComboBox/Dropdown/Tabs/LookupOptions/UiComponents.d.ts

@@ -0,0 +1,10 @@
+import { PropsWithChildren } from 'react';
+import { ButtonProps } from '../../../../../components/Button';
+export declare function PanelHeader({ children }: PropsWithChildren): 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 ParameterText({ title, value, }: {
+    title: string;
+    value?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function LookupOptionsTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,3 @@
+export declare function OptionsTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function VariablesTab({ onSelect }: {
+    onSelect: any;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { SvgIconType } from '../../SvgIcon';
+import { ComboBoxTabType, FnOnValueChangeType } from '../types';
+type RenderTabsType = Record<ComboBoxTabType, {
+    title: string;
+    icon?: SvgIconType;
+    showIfSingle?: boolean;
+    hideSearchInput?: boolean;
+}>;
+export declare const renderTabs: RenderTabsType;
+export declare const TAB_COMPONENTS: Record<ComboBoxTabType, React.FC<{
+    onSelect: FnOnValueChangeType;
+}>>;
+export {};

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ComboBoxComponentProps } from '../types';
+type OptionSelectorProps = ComboBoxComponentProps & {
+    valueComponent: React.ReactNode;
+};
+export declare function OptionSelector({ placeholder, className, onChange, disabled, required, valueComponent, }: OptionSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * from './OptionSelector';
+export * from './TextInput';

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { FormulaProps } from '../../DataBuilder/Formula';
+export interface ComboBoxFormulaValueProps extends Omit<FormulaProps<any>, 'formula'> {
+    value: any;
+    className?: string;
+}
+export declare const ComboBoxFormulaValue: import("react").ForwardRefExoticComponent<ComboBoxFormulaValueProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,4 @@
+/// <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

@@ -0,0 +1,5 @@
+/// <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>>;

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

@@ -0,0 +1,11 @@
+import { ComboBoxDropdownProps, ComboBoxOptionsProps } from '../types';
+interface ComboBoxContextProps extends ComboBoxOptionsProps {
+    allowCustom: boolean;
+    isDropdownOpen?: boolean;
+    openDropdown: () => void;
+    closeDropdown: () => void;
+    topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
+}
+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;
+export {};

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

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from 'react';
+import { ComboBoxOptionType, ComboBoxTabType, OptionsStateType } 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?];
+}
+export declare const ComboBoxDropdownContextProvider: ({ children, }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare function useComboBoxDropdownContext(): ComboBoxDropdownContextProps;
+export {};

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

@@ -0,0 +1,16 @@
+import { PropsWithChildren } from 'react';
+type SearchSource = 'editor' | 'combobox';
+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;
+}>) => import("react/jsx-runtime").JSX.Element;
+export declare function useComboBoxDropdownSearchContext(): ComboBoxSearchContextProps;
+export {};

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

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+import { RefOrElementType } from '../../../helpers/getRefElement';
+export declare const DropdownStackContextProvider: ({ children, }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useDropdownStackContext: (dropdownRef: RefOrElementType) => {
+    isClickInsideRefsAndChildren: (event: MouseEvent | TouchEvent) => boolean;
+};

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

@@ -0,0 +1,15 @@
+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, }: {
+    schema: DataSchema | undefined;
+    options: ComboBoxOptionType[] | undefined;
+    optionFactories: ComboBoxOptionsFactoryInterface[] | 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;

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

@@ -0,0 +1,5 @@
+export * from './combobox-context';
+export * from './combobox-dropdown-context';
+export * from './combobox-dropdown-search';
+export * from './combobox-dropdown-stack';
+export * from './helpers';

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

@@ -0,0 +1,7 @@
+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/options-factories/base.d.ts

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { ComboBoxOptionType, ValueDataType } from '../types';
+import { ComboBoxOptionsFactoryInterface } from '.';
+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 function isCustomFieldValue(value: ValueDataType): boolean;

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

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

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

@@ -0,0 +1,18 @@
+import { ComboBoxOptionType } from '../types';
+import { ValueSpecType } from '../value-spec';
+export * from './base';
+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;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { ComboBoxOptionType } from '../types';
+export declare class ReferenceUdmOptionFactory {
+    private schema;
+    constructor(schema: any);
+    getOptions({ input }: {
+        input: any;
+    }): Promise<ComboBoxOptionType[]>;
+}

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

@@ -0,0 +1,37 @@
+import { DataLocator } from '@integration-app/sdk';
+import { ComboBoxOptionType } from '../types';
+import { ValueSpecType } from '../value-spec';
+import { ComboBoxOptionsFactoryInterface } from '.';
+interface ISchemaOptionFactoryParameters {
+    schema: any;
+    locator?: DataLocator;
+    isSection?: boolean;
+    exampleVariables?: any;
+    editableSchemaLocators?: string[];
+}
+export declare class SchemaOptionFactory implements ComboBoxOptionsFactoryInterface {
+    private parameters;
+    constructor(parameters: ISchemaOptionFactoryParameters);
+    getOptions({ input, spec }: {
+        input: any;
+        spec: any;
+    }): Promise<ComboBoxOptionType[]>;
+    getOptionsSync({ input, spec }: {
+        input: any;
+        spec: any;
+    }): ComboBoxOptionType[];
+}
+export declare function getOptionsForSchema({ schema, locator, valueSpec, showIcons, skipNameComponentsPrefix, ignorePrefix, nameComponentsByLocator, schemaByLocator, exampleVariables, expandObject, editableSchemaLocators, }: {
+    schema: any;
+    locator: DataLocator;
+    valueSpec: ValueSpecType;
+    showIcons?: boolean;
+    skipNameComponentsPrefix?: Array<string>;
+    ignorePrefix?: boolean;
+    nameComponentsByLocator?: any;
+    schemaByLocator?: any;
+    exampleVariables?: any;
+    expandObject?: boolean;
+    editableSchemaLocators?: string[];
+}): ComboBoxOptionType[];
+export {};

package/dist/types/components/ComboBox/tests/Combobox.stories.helpers.d.ts

@@ -0,0 +1,35 @@
+import { ByRoleOptions } from '@testing-library/dom/types';
+export declare const sleep: (ms: any) => Promise<unknown>;
+export declare function withDocContext<T extends Record<string, any>>(story: T): T;
+export declare const Utils: {
+    WaitMenuOpen: {
+        play: (context: any) => Promise<void>;
+    };
+    WaitDropdownOpen: {
+        play: (context: any) => Promise<void>;
+    };
+    SkipLoader: {
+        play: (context: any) => Promise<void>;
+    };
+    OpenCombobox: {
+        play: (context: any, comboboxIdx?: number) => Promise<void>;
+    };
+    ClickMenuItem: {
+        play: (context: any, byRoleOptions: ByRoleOptions) => Promise<void>;
+    };
+    ClickListItem: {
+        play: (context: any, byRoleOptions: ByRoleOptions) => Promise<void>;
+    };
+    ClickAddField: {
+        play: (context: any) => Promise<void>;
+    };
+    ClickPopoverItem: {
+        play: (context: any, text: string) => Promise<void>;
+    };
+    ClickChangeSchemaType: {
+        play: (context: any) => Promise<void>;
+    };
+    ClickChangeSchemaTypeByIndex: {
+        play: (context: any, idx: any) => Promise<void>;
+    };
+};

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

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

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

@@ -0,0 +1,104 @@
+import { MutableRefObject, ReactNode } from 'react';
+import { DataLocator, DataSchema } from '@integration-app/sdk';
+import { SvgIconType } from '../SvgIcon';
+import { ComboBoxOptionsFactoryInterface } from './options-factories';
+import { ValueSpecType } from './value-spec';
+export type ValueDataType = any;
+type VariablesSchemaType = any;
+export type FnOnValueChangeType = (value: ValueDataType) => void;
+type FnInitEditModeType = () => void;
+type FnCloseEditModeType = () => void;
+type IsComboBoxDisabledType = boolean;
+type IsValueRequiredType = boolean;
+export type PopperRefElementType = HTMLElement | MutableRefObject<HTMLElement | null>;
+export interface ComboBoxOptionsProps {
+    value?: ValueDataType;
+    schema?: DataSchema;
+    valueSpec?: ValueSpecType;
+    variablesSchema?: VariablesSchemaType;
+    variablesOnly?: boolean;
+    options?: ComboBoxOptionType[];
+    optionFactories?: Array<ComboBoxOptionsFactoryInterface>;
+    refsToIgnoreClick?: PopperRefElementType[];
+}
+export interface ComboBoxProps extends ComboBoxOptionsProps {
+    valueComponent?: JSX.Element;
+    onChange: FnOnValueChangeType;
+    placeholder?: string;
+    hideSearch?: boolean;
+    isRequired?: IsValueRequiredType;
+    disabled?: IsComboBoxDisabledType;
+    className?: string;
+    autoOpen?: ComboBoxDropdownProps['autoOpen'];
+    onOpen?: ComboBoxDropdownProps['onDropdownOpen'];
+    onClose?: ComboBoxDropdownProps['onDropdownClose'];
+    topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
+}
+export interface ComboBoxComponentProps {
+    placeholder?: string;
+    className?: string;
+    onChange: FnOnValueChangeType;
+    required?: IsValueRequiredType;
+    disabled?: IsComboBoxDisabledType;
+    role?: string;
+    'aria-expanded'?: boolean;
+}
+export interface ComboBoxDropdownProps {
+    autoOpen?: boolean;
+    onDropdownOpen?: FnInitEditModeType;
+    onDropdownClose?: FnCloseEditModeType;
+    topDropdownPanelComponent?: JSX.Element;
+}
+export interface ComboBoxOptionType {
+    value?: ValueDataType;
+    label: ReactNode;
+    searchLabel?: string;
+    hint?: ReactNode;
+    isCustomValue?: boolean;
+    isSection?: boolean;
+    isHighlighted?: boolean;
+    drilldown?: DataLocator;
+    drilldownOptionFactories?: ComboBoxOptionsFactoryInterface[];
+    drillup?: boolean;
+    addVariable?: string;
+    group?: string;
+    iconUri?: string;
+    iconType?: SvgIconType;
+}
+export type ComboBoxTagVariantType = 'default' | 'lookup';
+export interface ComboBoxTagProps {
+    variant?: ComboBoxTagVariantType;
+    selected?: boolean;
+    onClick?: FnInitEditModeType;
+    tooltip?: string;
+    className?: string;
+    icon?: SvgIconType;
+    iconUri?: string;
+    children: ReactNode;
+    invalid?: boolean;
+    disabled?: IsComboBoxDisabledType;
+}
+export type OptionsStateType = 'rejected' | 'pending' | 'resolved';
+export interface ComboBoxValueProps {
+    className?: string;
+    placeholder?: string;
+    isEdited?: boolean;
+    disabled?: IsComboBoxDisabledType;
+    onClick?: FnInitEditModeType;
+    onChange?: FnOnValueChangeType;
+}
+export interface ComboBoxSchemaValueProps extends Omit<ComboBoxTagProps, 'children'> {
+    value: any;
+    schema: DataSchema | undefined;
+    variablesSchema: DataSchema | undefined;
+}
+export declare enum ComboBoxTabType {
+    VARIABLE = "variable",
+    OPTIONS = "options",
+    FORMULA = "formula",
+    CUSTOM = "custom",
+    LOOKUP_OPTIONS = "lookup_options",
+    SELECT_FROM_COLLECTION_DYNAMICALLY = "select_from_collection_dynamically",
+    SELECT_FROM_UDM_DYNAMICALLY = "select_from_udm_dynamically"
+}
+export {};