@membranehq/react 0.1.0

package/dist/types/_modules/awesome-debounce-promise.d.ts

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

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,3 @@
+import { ButtonProps, IconButtonProps } from './Button.types';
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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/Badges/ComboBoxFormulaBadge.d.ts

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

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

@@ -0,0 +1,11 @@
+import { HTMLAttributes } from 'react';
+import { DataSchema } from '@membranehq/sdk';
+type Props = {
+    value: unknown;
+    schema: DataSchema | undefined;
+    variablesSchema: DataSchema | undefined;
+    disabled?: boolean;
+    onDelete?: () => void;
+};
+export declare const ComboBoxSchemaValueBadge: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & Props & import("react").RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,10 @@
+type Props = {
+    className?: string;
+    placeholder?: string;
+    isDropdownOpen?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    onDelete?: () => void;
+};
+export declare const ComboBoxValueBadge: import("react").ForwardRefExoticComponent<Props & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/ComboBox/Badges/EditorTagBadge/NestedBadgeValue.d.ts

@@ -0,0 +1,6 @@
+export declare const nestedBadgeValueRecipe: import("../../../../styled-system/types").SlotRecipeRuntimeFn<"root" | "chunk" | "segment" | "visible-segment" | "truncated-segment", import("../../../../styled-system/types").SlotRecipeVariantRecord<"root" | "chunk" | "segment" | "visible-segment" | "truncated-segment">>;
+export declare function NestedBadgeValue({ nameChunks, fullName }: {
+    nameChunks: string[];
+    fullName: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ValueNestingIcon(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,66 @@
+import { HTMLAttributes } from 'react';
+import { SvgIconType } from '../../../../components/SvgIcon/svg-icon-type';
+export declare const editorTagBadgeRecipe: import("../../../../styled-system/types").SlotRecipeRuntimeFn<"icon" | "root" | "close-button-container" | "close-button", {
+    variant: {
+        'static-value': {
+            root: {
+                color: "black";
+                colorPalette: "gray";
+            };
+        };
+        formula: {
+            root: {
+                colorPalette: "indigo";
+            };
+        };
+        value: {
+            root: {
+                colorPalette: "blue";
+            };
+        };
+        error: {
+            root: {
+                colorPalette: "tomato";
+                color: "tomato.10";
+            };
+        };
+        ghost: {
+            root: {
+                bg: "transparent!";
+                borderColor: "transparent!";
+                "[data-selected='true'] &, [data-tag-dropdown-open='true'] &": {
+                    '& .editor-tag-badge__close-button-container': {
+                        gradientFrom: "transparent";
+                        gradientVia: "transparent";
+                        gradientTo: "transparent";
+                    };
+                };
+            };
+            'close-button': {
+                display: "none!";
+            };
+        };
+    };
+    disabled: {
+        true: {
+            root: {
+                pointerEvents: "none";
+                bg: "slate.4";
+                borderColor: "slate.5";
+                color: "black";
+                cursor: "initial";
+            };
+        };
+        false: {};
+    };
+}>;
+export declare const EditorTagBadge: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    variant?: "value" | "error" | "ghost" | "formula" | "static-value" | undefined;
+    disabled?: boolean | undefined;
+} & {
+    onDelete?: () => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare function EditorTagBadgeIcon({ type, className }: {
+    type: SvgIconType;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export * from './ComboBoxFormulaBadge';
+export * from './ComboBoxSchemaValueBadge';
+export * from './ComboBoxValueBadge';

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

@@ -0,0 +1 @@
+export declare function isDefinedValue(value: unknown): value is {};

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

@@ -0,0 +1,4 @@
+import { ComboBoxProps } from './types';
+export declare function ComboBox({ value, schema, valueSpec, variablesSchema, variablesOnly, options, optionFactories, onChange, valueComponent, placeholder, isRequired, disabled, className, hideSearch, autoOpen, onOpen, onClose, topDropdownPanelComponent, refsToIgnoreClick, onValueChange: _, ...rest }: ComboBoxProps & {
+    'data-selected'?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ComboBoxComponentProps } from '../types';
+export declare function ComboboxTagTrigger({ placeholder, className, onChange, disabled, valueComponent, ...rest }: ComboBoxComponentProps & {
+    valueComponent: React.ReactNode;
+}): 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 '@membranehq/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/Categories/LookupOptions/UiComponents.d.ts

@@ -0,0 +1,14 @@
+import { PropsWithChildren } from 'react';
+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;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { FnOnValueChangeType } from '../../../types';
+export declare const LookupOptionsCategoryContent: import("react").NamedExoticComponent<{
+    onOptionSelect: FnOnValueChangeType;
+    children?: React.ReactNode;
+}>;
+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 '@membranehq/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

@@ -0,0 +1,10 @@
+import { ComboBoxDropdownProps, FnOnValueChangeType } from '../types';
+export interface DropdownProps {
+    topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
+    onOptionSelect: FnOnValueChangeType;
+    autoFocusOnSearch?: boolean;
+    editorRef?: React.RefObject<HTMLElement>;
+    searchInputRef?: React.RefObject<HTMLInputElement>;
+    children?: React.ReactNode;
+}
+export declare function Dropdown({ topDropdownPanelComponent, autoFocusOnSearch, onOptionSelect, editorRef, searchInputRef, children, }: DropdownProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { ComboBoxOption } from '../../shared';
+export declare function NavigationContextProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useNavigationContext(options?: ComboBoxOption[], fallbackOptions?: ComboBoxOption[]): {
+    currentItem: ComboBoxOption | "drill-up" | null;
+    moveToNextItem: () => void;
+    moveToPreviousItem: () => void;
+};

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

@@ -0,0 +1,6 @@
+import { ComboBoxOption } from '../../../../components/ComboBox/shared';
+export declare const useKeyboardBinding: ({ options, fallbackOptions, onEnter, }: {
+    options: ComboBoxOption[];
+    fallbackOptions: ComboBoxOption[];
+    onEnter?: (option: ComboBoxOption | "drill-up") => void;
+}) => void;

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

@@ -0,0 +1,7 @@
+import { ComboBoxOption } from '../shared';
+export default function DropdownOption({ option, selected, current, onSelect, }: {
+    option: ComboBoxOption;
+    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({ onOptionSelect }: {
+    onOptionSelect: FnOnValueChangeType;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare const SearchInput: import("react").ForwardRefExoticComponent<{
+    autoFocus?: boolean;
+} & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,6 @@
+import { DropdownCategoryType } from '../shared';
+import { FnOnValueChangeType } from '../types';
+export declare const CATEGORY_COMPONENTS: Record<DropdownCategoryType, React.FC<{
+    onOptionSelect: FnOnValueChangeType;
+    onConfigSelect?: (category: DropdownCategoryType) => void;
+}>>;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const DropdownPositioner: React.FC<{
+    children: React.ReactNode;
+}>;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+export declare function DropdownPopoverProvider({ children, disabled }: {
+    children?: React.ReactNode;
+    disabled?: boolean;
+}): 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/FocusTrap/index.d.ts

@@ -0,0 +1,4 @@
+export declare function DropdownFocusTrap({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { ComboBoxDropdownProps, ComboBoxOptionsProps } from '../types';
+interface ComboBoxContextProps extends ComboBoxOptionsProps {
+    allowCustom: boolean;
+    isDropdownOpen?: boolean;
+    openDropdown: () => void;
+    closeDropdown: () => void;
+    topDropdownPanelComponent?: ComboBoxDropdownProps['topDropdownPanelComponent'];
+    scopedComboboxId: string;
+}
+export declare const ComboBoxProvider: ({ value, onValueChange, 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,19 @@
+import { PropsWithChildren } from 'react';
+import { usePromise } from '../../../hooks/usePromise';
+import { ComboBoxOption, DropdownCategoryType } from '../shared';
+interface ComboBoxDropdownContextProps {
+    availableCategories: DropdownCategoryType[] | null;
+    activeCategory: DropdownCategoryType;
+    drillDown: (option: ComboBoxOption) => void;
+    drillUp: () => void;
+    isOptionSelected: (option: ComboBoxOption) => boolean;
+    optionsPayload: ReturnType<typeof usePromise<{
+        options: ComboBoxOption[];
+        fallbackOptions: ComboBoxOption[];
+    }>>;
+    canUseParentInputSearchValue: boolean;
+    drillDownStackTop?: ComboBoxOption;
+}
+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,14 @@
+import { PropsWithChildren } from 'react';
+type SearchSource = 'indeterminate' | 'parent-input' | 'dropdown-search-input';
+interface ComboBoxSearchContextProps {
+    hideSearch: boolean;
+    dropdownSearchInputValue: string;
+    setDropdownSearchInputValue: (value: string) => void;
+    searchSource: SearchSource;
+    setSearchSource: (target: SearchSource) => void;
+}
+export declare const ComboBoxDropdownSearchProvider: ({ children, hideSearch, }: PropsWithChildren<{
+    hideSearch?: boolean;
+}>) => 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,7 @@
+import { PropsWithChildren, RefObject } from 'react';
+export declare const DropdownStackContextProvider: ({ children, editorRef, }: PropsWithChildren & {
+    editorRef?: React.RefObject<HTMLElement>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useDropdownStackContext: (dropdownRef: RefObject<HTMLElement>) => {
+    isClickWithinStackItem: (event: MouseEvent | TouchEvent) => boolean;
+};

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

@@ -0,0 +1,15 @@
+import { DataSchema, IntegrationAppClient } from '@membranehq/sdk';
+import { ComboBoxOption, ValueDataType, ComboBoxOptionsFactory, DropdownCategoryType } from '../shared';
+export declare function getAvailableRootCategories({ schema, options, optionFactories, variablesOnly, hasVariables, client, connectionId, integrationId, }: {
+    schema: DataSchema | undefined;
+    options: ComboBoxOption[] | undefined;
+    optionFactories: ComboBoxOptionsFactory[] | undefined;
+    variablesOnly: boolean | undefined;
+    hasVariables: boolean;
+    client: IntegrationAppClient;
+    connectionId: string;
+    integrationId: string;
+}): 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/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/options-factories/boolean.d.ts

@@ -0,0 +1,6 @@
+import { ComboBoxOption, ComboBoxOptionsFactory } from '../shared';
+import { 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

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

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

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

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

@@ -0,0 +1,5 @@
+import { ComboBoxOption, ComboBoxOptionsFactory } from '../../../../components/ComboBox/shared';
+import { GetOptionsArgs } from '../types';
+export declare class CustomFieldOptionsFactory implements ComboBoxOptionsFactory {
+    getOptions({ spec, input }: GetOptionsArgs): Promise<ComboBoxOption[]>;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { DataBuilderFormulaType } from '@membranehq/sdk';
+import { ValueSpecType } from '../../../../components/ComboBox/value-spec';
+interface FormulaConfig {
+    name?: string;
+    appliesToSpec?: (spec: ValueSpecType) => boolean;
+}
+export declare const formulaConfigMapping: Record<DataBuilderFormulaType, FormulaConfig>;
+export {};

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

@@ -0,0 +1,7 @@
+import { ComboBoxOption, ComboBoxOptionsFactory } from '../../shared';
+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 '@membranehq/sdk';
+import { ComboBoxOption } from '../shared';
+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

@@ -0,0 +1,9 @@
+export { BooleanOptionsFactory } from './boolean';
+export { ConstantOptionFactory } from './constant';
+export { CustomFieldOptionsFactory } from './custom-field';
+export { EnumOptionFactory } from './enum';
+export { FormulaListOptionsFactory } from './formula';
+export { ObjectFieldsOptionFactory } from './object-fields';
+export { ReferenceRecordsOptionsFactory } from './reference-records';
+export { RootOptionFactory } from './root';
+export { VariableOptionFactory } from './variable';

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

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

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

@@ -0,0 +1,13 @@
+import { ComboBoxOption, ComboBoxOptionsFactory } from '../shared';
+import { GetOptionsArgs } from './types';
+interface IReferenceRecordsOptionsFactoryParameters {
+    schema: any;
+    iconUri?: string;
+}
+export declare class ReferenceRecordsOptionsFactory implements ComboBoxOptionsFactory {
+    private params;
+    constructor(params: IReferenceRecordsOptionsFactoryParameters);
+    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 { ComboBoxOptionsFactory, ComboBoxOption, DropdownCategoryType } from '../shared';
+import { GetOptionsArgs } from './types';
+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,9 @@
+import { DataSchema } from '@membranehq/sdk';
+import { IDataBuilderContext } from '../../../components/DataBuilder/types';
+import { ValueSpecType } from '../value-spec';
+export type GetOptionsArgs = {
+    input: string;
+    spec?: ValueSpecType;
+    variablesSchema?: DataSchema;
+    editableVariablesSchemaLocators?: IDataBuilderContext['editableVariablesSchemaLocators'];
+};

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

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

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

@@ -0,0 +1,17 @@
+import { DataLocator } from '@membranehq/sdk';
+import { ComboBoxOptionsFactory, ComboBoxOption } from '../shared';
+import { 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 {};