@uniformdev/mesh-sdk-react 19.35.2 → 19.35.3-alpha.82

package/dist/index.d.mts

@@ -0,0 +1,1480 @@
+import * as _emotion_react_types_jsx_namespace from '@emotion/react/types/jsx-namespace';
+import * as React$1 from 'react';
+import React__default, { SVGProps, ReactNode, MutableRefObject, ComponentType, PropsWithChildren, HTMLAttributes, AnchorHTMLAttributes } from 'react';
+import { TDate } from 'timeago.js';
+import * as _emotion_react from '@emotion/react';
+import * as _uniformdev_mesh_sdk from '@uniformdev/mesh-sdk';
+import { DynamicInput, MeshLocation, SetValueOptions, DynamicInputs, DataSourceLocationValue, DataTypeLocationValue, BindableTypes } from '@uniformdev/mesh-sdk';
+export * from '@uniformdev/mesh-sdk';
+import { DataVariableDefinition, DataResourceVariables, DataType } from '@uniformdev/canvas';
+import { Emitter } from 'mitt';
+import { BadgeThemeProps, InputSelectProps } from '@uniformdev/design-system';
+export { AddListButton, AddListButtonProps, Button, ButtonProps, Callout, CalloutProps, DrawerContent, Heading, HeadingProps, Input, InputComboBox, InputComboBoxProps, InputKeywordSearch, InputProps, InputSelect, InputToggle, InputToggleProps, Label, LabelProps, LoadingIndicator, LoadingOverlay, Menu, MenuItem, MenuItemProps, MenuProps, ParameterGroup, ParameterGroupProps, ParameterImage, ParameterImageInner, ParameterImageProps, ParameterInput, ParameterInputInner, ParameterInputProps, ParameterLabel, ParameterLabelProps, ParameterMenuButton, ParameterMenuButtonProps, ParameterSelect, ParameterSelectInner, ParameterSelectProps, ParameterShell, ParameterShellContext, ParameterShellProps, ParameterTextarea, ParameterTextareaInner, ParameterTextareaProps, ParameterToggle, ParameterToggleInner, ParameterToggleProps, ScrollableList, ScrollableListItem, ScrollableListItemProps, ScrollableListProps, Switch, SwitchProps, Textarea, TextareaProps, Theme, ThemeProps, useParameterShell } from '@uniformdev/design-system';
+import * as lexical from 'lexical';
+import { SerializedEditorState, SerializedLexicalNode, Spread, DecoratorNode, NodeKey, LexicalEditor, LexicalNode, EditorState } from 'lexical';
+import { MenuOption } from '@lexical/react/LexicalTypeaheadMenuPlugin';
+
+declare const SvgCaution: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgCheckmark: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgChevronDown: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgClose: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgDanger: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgExclamationPoint: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgInfo: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgLightbulb: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgMagnifyingGlass: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgMaximizeAlt: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgMinus: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgMoreVerticalAlt: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const SvgPlus: (props: SVGProps<SVGSVGElement>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare namespace index {
+  export {
+    SvgCaution as Caution,
+    SvgCheckmark as Checkmark,
+    SvgChevronDown as ChevronDown,
+    SvgClose as Close,
+    SvgDanger as Danger,
+    SvgExclamationPoint as ExclamationPoint,
+    SvgInfo as Info,
+    SvgLightbulb as Lightbulb,
+    SvgMagnifyingGlass as MagnifyingGlass,
+    SvgMaximizeAlt as MaximizeAlt,
+    SvgMinus as Minus,
+    SvgMoreVerticalAlt as MoreVerticalAlt,
+    SvgPlus as Plus,
+  };
+}
+
+interface EntrySearchSelectedItemProps<TResult extends EntrySearchResult = EntrySearchResult> {
+    selectedItem: TResult;
+    logoIcon: string | React__default.ComponentType<{
+        className?: string;
+    }>;
+    onDeselect: (item: TResult) => void;
+    onEditClosed?: (item: TResult) => void;
+}
+declare const DefaultSelectedItem: React__default.FC<EntrySearchSelectedItemProps>;
+
+type EntrySearchQueryOptions = {
+    count: number;
+    offset: number;
+    contentType?: string;
+    cursor?: string;
+};
+type EntrySearchProps<TResult extends EntrySearchResult = EntrySearchResult> = {
+    search: (text: string, options: EntrySearchQueryOptions) => void;
+    results: TResult[] | undefined;
+    totalResults?: number | undefined;
+    cursor?: string;
+    contentTypes?: EntrySearchContentType[];
+    selectedItems: TResult[] | undefined;
+    logoIcon: string | React$1.ComponentType<{
+        className?: string;
+    }>;
+    select: (items: TResult[], selectedContentType?: string) => void;
+    requireContentType?: boolean;
+    multiSelectId?: string;
+    multiSelect?: boolean;
+    rowComponent?: React$1.FC<EntrySearchRowProps<TResult>>;
+    selectedItemComponent?: React$1.FC<EntrySearchSelectedItemProps<TResult>>;
+    onAddNew?: (type: EntrySearchContentType) => void;
+    onEditClosed?: (item: EntrySearchResult) => void;
+    onCancel?: () => void;
+    resultsLoading?: boolean;
+    noResultsComponent?: React$1.FC<{
+        searchText?: string;
+        selectedContentType?: string;
+    }>;
+    helpComponent?: JSX.Element;
+    onSort?: (items: TResult[]) => void;
+    typeSelectorLabel?: string;
+    typeSelectorAllTypesOptionText?: string;
+    /** Specifies how long (in milliseconds) to wait before showing the loading indicator when `resultsLoading` is true.
+     * @default 1000
+     */
+    loadingIndicatorDelay?: number;
+};
+interface EntrySearchResult {
+    id: string;
+    title: string | JSX.Element;
+    createdDate?: TDate;
+    editLink?: string;
+    metadata?: Record<string, string | JSX.Element>;
+    popoverData?: Record<string, string | JSX.Element>;
+}
+interface EntrySearchContentType {
+    id: string;
+    name: string;
+}
+interface NoResultsProps {
+    searchText: string | undefined;
+    selectedContentType: string | undefined;
+}
+declare const EntrySearch: <TResult extends EntrySearchResult>({ search, results, contentTypes, selectedItems, logoIcon, select, multiSelect, multiSelectId, rowComponent, selectedItemComponent, totalResults, cursor, resultsLoading, requireContentType, onAddNew, onEditClosed, onCancel, noResultsComponent, helpComponent, onSort, typeSelectorLabel, typeSelectorAllTypesOptionText, loadingIndicatorDelay, }: EntrySearchProps<TResult>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+interface EntrySearchRowProps<TResult extends EntrySearchResult = EntrySearchResult> {
+    result: TResult;
+    isSelected: boolean;
+    triggerSelection: () => void;
+}
+declare const DefaultSearchRow: React__default.FC<EntrySearchRowProps>;
+
+declare const searchRowContainer: _emotion_react.SerializedStyles;
+declare const searchRowContainerWithPopover: _emotion_react.SerializedStyles;
+declare const searchRowContainerActive: _emotion_react.SerializedStyles;
+declare const searchRowTextSmall: _emotion_react.SerializedStyles;
+declare const searchRowText: _emotion_react.SerializedStyles;
+declare const searchRowPopover: _emotion_react.SerializedStyles;
+declare const searchRowBtn: _emotion_react.SerializedStyles;
+
+declare const selectedItemContainer: _emotion_react.SerializedStyles;
+declare const selectedItemInner: _emotion_react.SerializedStyles;
+declare const selectedItemDetails: _emotion_react.SerializedStyles;
+declare const selectedItemCopy: _emotion_react.SerializedStyles;
+declare const selectedItemTitle: _emotion_react.SerializedStyles;
+declare const selectedItemIcon: _emotion_react.SerializedStyles;
+declare const selectItemPopover: _emotion_react.SerializedStyles;
+declare const selectItemSmallText: _emotion_react.SerializedStyles;
+declare const selectItemPopoverLabel: _emotion_react.SerializedStyles;
+declare const selectItemLinkContainer: _emotion_react.SerializedStyles;
+declare const selectItemLinkBtn: _emotion_react.SerializedStyles;
+
+declare const entrySearchWrapper: _emotion_react.SerializedStyles;
+declare const entrySearchBtn: _emotion_react.SerializedStyles;
+declare const entrySearchLoadMoreBtn: _emotion_react.SerializedStyles;
+declare const entrySearchConfig: _emotion_react.SerializedStyles;
+declare const entrySearchConfigHidden: _emotion_react.SerializedStyles;
+declare const entrySearchResultList: _emotion_react.SerializedStyles;
+declare const entrySearchSelectInput: _emotion_react.SerializedStyles;
+declare const entrySearchSelectIcon: _emotion_react.SerializedStyles;
+declare const entrySearchSelectImg: _emotion_react.SerializedStyles;
+declare const entrySearchSelectOption: _emotion_react.SerializedStyles;
+declare const draggableContainer: _emotion_react.SerializedStyles;
+declare const draggableIconWrapper: _emotion_react.SerializedStyles;
+declare const draggableIcon: _emotion_react.SerializedStyles;
+declare const draggableIconOffset: _emotion_react.SerializedStyles;
+declare const badgeIcon: _emotion_react.SerializedStyles;
+
+type GetProductsOptions = {
+    keyword?: string;
+    count?: number;
+    categories?: string[];
+    brand?: string;
+    sort?: string;
+    sortOrder?: string;
+    ids?: string[];
+    offset?: number;
+};
+type ProductSearchResult = EntrySearchResult & {
+    price?: number | string;
+    sku?: string;
+    thumbnailUrl?: string;
+    categories?: Array<{
+        id: string;
+        name: string;
+    }>;
+};
+interface ProductSearchResults {
+    total: number;
+    products: ProductSearchResult[];
+}
+interface ProductCategory {
+    id: string;
+    name: string;
+    children?: ProductCategory[];
+}
+
+declare const ProductPreviewList: ({ products, }: {
+    products: ProductSearchResults['products'] | undefined;
+}) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+interface ProductDynamicSelectorValue {
+    count: number;
+    categories?: string[];
+    brand?: string;
+    keyword?: string;
+    sort?: string;
+    sortOrder?: string;
+}
+interface ProductQueryProps<TValue extends ProductDynamicSelectorValue = ProductDynamicSelectorValue> {
+    value: TValue | undefined;
+    setValue: (value: TValue) => Promise<void>;
+    brands: Brand[] | undefined;
+    categories: ProductQueryCategory[] | undefined;
+    loading?: boolean;
+    categoriesLoading?: boolean;
+    brandsLoading?: boolean;
+    logoIcon?: string | React__default.ComponentType<{
+        className?: string;
+    }>;
+    onGetProducts: (options?: GetProductsOptions) => Promise<ProductSearchResults>;
+    sortOptions?: Array<{
+        name: string;
+        sortKey: string;
+    }>;
+    sortOrderOptions?: Array<{
+        name: string;
+        sortOrderKey: string;
+    }>;
+    categoryLabel?: string;
+    brandLabel?: string;
+    disableBrands?: boolean;
+    restrictToSingleCategory?: boolean;
+}
+interface ProductQueryCategory {
+    id: string;
+    name: string;
+    children?: ProductQueryCategory[];
+}
+interface Brand {
+    id: string;
+    name: string;
+}
+declare const ProductQuery: ({ value, setValue, brands, categories, loading, categoriesLoading, brandsLoading, logoIcon, onGetProducts, sortOptions, sortOrderOptions, categoryLabel, brandLabel, disableBrands, restrictToSingleCategory, }: ProductQueryProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+interface ProductQueryContextValue {
+    categories: ProductQueryProps['categories'];
+    logoIcon: ProductQueryProps['logoIcon'];
+}
+declare const ProductQueryContext: React__default.Context<ProductQueryContextValue | undefined>;
+declare const useProductQueryContext: () => ProductQueryContextValue;
+
+type ProductSearchProps<TResult extends ProductSearchResult = ProductSearchResult> = Pick<EntrySearchProps<TResult>, 'multiSelect' | 'multiSelectId' | 'logoIcon' | 'rowComponent' | 'selectedItemComponent' | 'helpComponent' | 'noResultsComponent' | 'onSort' | 'typeSelectorAllTypesOptionText' | 'typeSelectorLabel'> & {
+    selectedProducts: TResult[] | undefined;
+    setSelectedProducts: (products: TResult[] | undefined) => Promise<void>;
+    onGetCategories: () => Promise<ProductCategory[]>;
+    onSearchProducts: (args: {
+        text: string;
+        options?: GetProductOptions;
+    }) => Promise<{
+        total: number;
+        products: TResult[];
+        cursor?: string;
+    }>;
+    errorComponent?: React__default.ComponentType<{
+        categoriesError?: Error;
+        searchError?: Error;
+    }>;
+};
+interface GetProductOptions {
+    limit?: number;
+    offset?: number;
+    categoryId?: string;
+    cursor?: string;
+}
+declare function ProductSearch({ selectedProducts, setSelectedProducts, onGetCategories, onSearchProducts, logoIcon, multiSelect, multiSelectId, selectedItemComponent, rowComponent, errorComponent, helpComponent, noResultsComponent, onSort, typeSelectorAllTypesOptionText, typeSelectorLabel, }: ProductSearchProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+interface ProductSearchContextValue {
+    logoIcon: ProductSearchProps['logoIcon'];
+    categories: ProductCategory[] | undefined;
+}
+declare const ProductSearchContext: React__default.Context<ProductSearchContextValue | undefined>;
+declare const useProductSearchContext: () => ProductSearchContextValue;
+
+declare function ProductSearchRow({ result, isSelected, triggerSelection, }: EntrySearchRowProps<ProductSearchResult>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare function ProductSelectedItem({ selectedItem, onDeselect, }: EntrySearchSelectedItemProps<ProductSearchResult>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const ResolvableLoadingValue: ({ value, text, loading, }: {
+    value: string;
+    text: string | undefined;
+    loading: boolean;
+}) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type SelectionFieldValue = {
+    id: string;
+    name: string;
+};
+declare const SelectionField: ({ id, label, loading, selectedValues, values, onAdd, onRemove, }: {
+    id: string;
+    label: string;
+    loading: boolean;
+    selectedValues: string[] | undefined;
+    values: SelectionFieldValue[];
+    onAdd: (id: string) => void;
+    onRemove: (id: string) => void;
+}) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const productSearchRowContainer: _emotion_react.SerializedStyles;
+declare const productSearchRowContent: _emotion_react.SerializedStyles;
+declare const productSearchRowContentActive: _emotion_react.SerializedStyles;
+declare const productSearchRowTitle: _emotion_react.SerializedStyles;
+declare const productSearchRowCategory: _emotion_react.SerializedStyles;
+declare const productSearchRowDetails: _emotion_react.SerializedStyles;
+declare const productSearchRowActiveIcon: _emotion_react.SerializedStyles;
+
+declare const productSelectedItemContainer: _emotion_react.SerializedStyles;
+declare const productSelectedItemDetails: _emotion_react.SerializedStyles;
+declare const productSelectedItemContent: _emotion_react.SerializedStyles;
+declare const productSelectedItemImage: _emotion_react.SerializedStyles;
+declare const productedSelectedItemLinkBtn: _emotion_react.SerializedStyles;
+declare const productedSelectedItemSmallText: _emotion_react.SerializedStyles;
+declare const productSelectedItemIcon: _emotion_react.SerializedStyles;
+declare const productSelectedItemLinkContainer: _emotion_react.SerializedStyles;
+
+interface DamItem {
+    id: string;
+    title: string | JSX.Element;
+    createdDate?: Date | string | number;
+    editLink?: string | JSX.Element;
+    metadata?: Record<string, string | JSX.Element>;
+    popoverData?: Record<string, string | JSX.Element>;
+    previewUrl?: string | JSX.Element;
+    type: 'image' | 'video' | 'file' | 'other';
+}
+
+interface DamSelectedItemProps<TResult extends DamItem = DamItem> {
+    /** The item used for rendering this component. */
+    selectedItem: TResult;
+    /** Logo icon is used for the `editLink` if `editLink` is a string value, otherwise the icon is not used. */
+    logoIcon?: string | React__default.ComponentType<{
+        className?: string;
+    }>;
+    /** Callback that is invoked when the "Unlink" (deselect) button is clicked. */
+    onDeselect: (item: TResult) => void;
+    /** If `editLink` is a string value, an `<a>` element will be rendered for the `editLink` and
+     * the `onEditClosed` callback will be invoked when the tab opened by clicking the `<a>` element is closed. */
+    onEditClosed?: (item: TResult) => void;
+    /** Allows for customizing how item details, e.g. item preview, item metadata, are rendered. If not defined,
+     * item details will be rendered using the default (built-in) renderer.
+     */
+    itemDetailsRendererComponent?: React__default.ComponentType<{
+        item: TResult;
+    }>;
+}
+declare function DamSelectedItem({ selectedItem, onDeselect, onEditClosed, logoIcon, itemDetailsRendererComponent, }: DamSelectedItemProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare const damSelectedItemContainer: _emotion_react.SerializedStyles;
+declare const damSelectedItemInner: _emotion_react.SerializedStyles;
+declare const damSelectedItemDetails: _emotion_react.SerializedStyles;
+declare const damSelectedItemCopy: _emotion_react.SerializedStyles;
+declare const damSelectedItemTitle: _emotion_react.SerializedStyles;
+declare const damSelectedItemIcon: _emotion_react.SerializedStyles;
+declare const damSelectedItemPopover: _emotion_react.SerializedStyles;
+declare const damSelectedItemSmallText: _emotion_react.SerializedStyles;
+declare const damSelectedItemPopoverLabel: _emotion_react.SerializedStyles;
+declare const damSelectedItemLinkContainer: _emotion_react.SerializedStyles;
+declare const damSelectedItemLinkBtn: _emotion_react.SerializedStyles;
+declare const damSelectedItemMediaContainer: _emotion_react.SerializedStyles;
+declare const damSelectedItemInfoBtn: _emotion_react.SerializedStyles;
+declare const damSelectItemImage: _emotion_react.SerializedStyles;
+
+type MinimalDynamicInput = Omit<DynamicInput, 'source'>;
+type MinimalDynamicInputs = Record<string, MinimalDynamicInput>;
+type DataResourceDynamicInputProviderProps = {
+    /** Explicitly provide dynamic input values. If not set, Mesh location will be used */
+    dynamicInputs?: MinimalDynamicInputs;
+    /** Child components of the provider. Variables-using components, such as InputVariables, can be used here. */
+    children: ReactNode;
+};
+/**
+ * Wrapper for data resource locations. Provides read-only access to dynamic inputs as if they were variables,
+ * using variables-aware components (i.e. InputVariables). This simplifies building dynamic-input-aware editors,
+ * where a data resource variable could be a static value or bound to a dynamic input from the route (project map).
+ */
+declare function DataResourceDynamicInputProvider(props: DataResourceDynamicInputProviderProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/**
+ * Provides convenient access to the current Uniform Mesh location via React hook.
+ * Intended to be used within <MeshApp />.
+ *
+ * There are three primary ways to invoke this hook:
+ * 1. Without any arguments, this hook will return the current location regardless of its type. The result will be a union of all possible locations you can discriminate between i.e. with an if statement on the `type`
+ *    const location = useMeshLocation();
+ *    if (location.type === 'paramType') { // location is now known to be a paramType }
+ * 2. With a string argument, this hook will assert that the current location is the expected one and return the correct typings for that location.
+ *    const location = useMeshLocation('settings');
+ * 3. With an explicit generic to set the expected param type data or param type settings data. This is useful because (2) will return unknown as the value type for param types.
+ *    const location = useMeshLocation<'paramType', MyParamTypeValueType>();
+ *
+ * You can also combine (2) and (3) to get both explicit value typing and assertion of the location.
+ */
+declare function useMeshLocation<TLocationType extends MeshLocation['type'], TLocationValue = unknown, TLocationSetValue = TLocationValue>(expectedLocation?: TLocationType): Omit<Extract<_uniformdev_mesh_sdk.DataSourceLocation, {
+    type: TLocationType;
+}> | Extract<_uniformdev_mesh_sdk.DataTypeLocation, {
+    type: TLocationType;
+}> | Extract<_uniformdev_mesh_sdk.DataResourceLocation, {
+    type: TLocationType;
+}> | Extract<_uniformdev_mesh_sdk.ParamTypeLocation<TLocationValue, unknown, TLocationSetValue, unknown>, {
+    type: TLocationType;
+}> | Extract<_uniformdev_mesh_sdk.ParamTypeConfigLocation<TLocationValue, unknown>, {
+    type: TLocationType;
+}> | Extract<_uniformdev_mesh_sdk.SettingsLocation<TLocationValue>, {
+    type: TLocationType;
+}>, "setValue"> & {
+    setValue: SetLocationValueDispatch<(Extract<_uniformdev_mesh_sdk.DataSourceLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.DataTypeLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.DataResourceLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.ParamTypeLocation<TLocationValue, unknown, TLocationSetValue, unknown>, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.ParamTypeConfigLocation<TLocationValue, unknown>, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.SettingsLocation<TLocationValue>, {
+        type: TLocationType;
+    }>)["value"], Parameters<(Extract<_uniformdev_mesh_sdk.DataSourceLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.DataTypeLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.DataResourceLocation, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.ParamTypeLocation<TLocationValue, unknown, TLocationSetValue, unknown>, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.ParamTypeConfigLocation<TLocationValue, unknown>, {
+        type: TLocationType;
+    }> | Extract<_uniformdev_mesh_sdk.SettingsLocation<TLocationValue>, {
+        type: TLocationType;
+    }>)["setValue"]>[0]>;
+};
+type SetLocationValueDispatch<TValue, TSetValue = TValue> = (dispatch: SetLocationValueFunction<TValue, TSetValue>) => Promise<void> | void;
+type SetLocationValueFunction<TValue, TSetValue> = (previousValue: TValue) => DispatchResult<TSetValue>;
+type DispatchResult<TSetValue> = {
+    options?: SetValueOptions;
+    newValue: TSetValue;
+};
+
+/**
+ * Updates the Lexical editor state automatically when a controlled value changes, effectively
+ * turning the Lexical editor into a controlled component.
+ *
+ * DO NOT USE THIS when actually editing with Lexical as it will cause performance problems.
+ * This is intended to be used:
+ * * To simplify a read-only "preview" editor, where the user can't edit the value
+ * * To sync an external state with the Lexical editor state under certain conditions (i.e. composer mounted, but editor hidden)
+ */
+declare function ControlledValuePlugin({ enabled, value, extraDependencies, }: {
+    /** Whether to enable the controlled value plugin. Defaults to false. The value is only controlled when set to true. */
+    enabled: boolean;
+    value: string | undefined | SerializedEditorState<SerializedLexicalNode>;
+    extraDependencies?: unknown[];
+}): JSX.Element | null;
+
+type SerializedVariableNode = Spread<{
+    reference: string;
+    type: 'variable';
+    version: 1;
+}, SerializedLexicalNode>;
+type VariableNodeState = {
+    /** Display name to show on the variable */
+    displayName: string;
+    /**
+     * Whether the variable reference is currently pointing to a known variable in the variables context
+     * Note that this is ignored if `isFresh` is true, which is set for the result of edits or insertions
+     * made after the editor has mounted (which we know are good and don't validate to prevent flicker or false errors)
+     */
+    referenceIsValid: boolean;
+    /**
+     * Whether the variable node has been inserted or edited during this editing session
+     * Fresh nodes are always considered "valid" because they are the result of a user action
+     */
+    isFresh: boolean;
+    /** Whether clicking the node has an effect (dispatching an edit event) */
+    hasClickEvent: boolean | undefined;
+    /** Tooltip of the node on hove */
+    tooltip: string | undefined;
+};
+/** Renders a variable reference node within a Lexical editor */
+declare class VariableNode extends DecoratorNode<JSX.Element> {
+    reference: Readonly<string>;
+    private __state;
+    static getType(): string;
+    static clone(node: VariableNode): VariableNode;
+    /** Imports the node from serialized JSON (i.e. the data provided to the editor's initial state) */
+    static importJSON(serializedNode: SerializedVariableNode): VariableNode;
+    constructor(reference: Readonly<string>, state: VariableNodeState, key?: NodeKey);
+    /** Gets the node's current state */
+    getState(): VariableNodeState;
+    /**
+     * Updates the node's variables state so it knows its current validity, display name, etc
+     * The plugin updates this whenever the variables prop changes.
+     */
+    setState(state: VariableNodeState): void;
+    /**
+     * Serializes the node to JSON for editor initial state
+     */
+    exportJSON(): {
+        reference: string;
+        type: string;
+        version: number;
+    };
+    /**
+     * Copy variable to clipboard in a format we will read back if pasted
+     * (albeit it won't get the fancy chip-node)
+     */
+    getTextContent(): string;
+    /** Creates the DOM wrapper that hosts the node */
+    createDOM(): HTMLSpanElement;
+    updateDOM(): boolean;
+    /**
+     * Render the variable node using React.
+     * NOTE: this is effectively an island of React, and you may not call hooks,
+     * rely on Context, etc in this renderer.
+     */
+    decorate(editor: LexicalEditor): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+    /** Enables keyboard navigation to hop over the node to previous text */
+    isIsolated(): boolean;
+}
+declare function $createVariableNode(variableReference: string, state: VariableNodeState): VariableNode;
+declare function $isVariableNode(node: LexicalNode | null | undefined): node is VariableNode;
+
+type MeshDataVariableDefinition = Omit<DataVariableDefinition, 'default'> & {
+    /** When used in code, variables may have non-string defaults */
+    default: unknown;
+    /**
+     * If true the variable will not be shown in variables listings and menus, but can still be resolved
+     * Useful for variables that are defined by their presence in a value, and disappear when deleted from the value,
+     * like bindings.
+     */
+    ephemeral?: boolean;
+    /**
+     * Prevents editing the variable if set to true. If the variable context is set to read only,
+     * this is ignored and is always effectively true.
+     */
+    readOnly?: boolean;
+    /**
+     * Tooltip for the variable when rendered in content UI.
+     * If not passed, defaults to helpText.
+     */
+    tooltip?: string;
+};
+type DataVariableDefinitionWithName = {
+    name: string;
+} & MeshDataVariableDefinition;
+/**
+ * Converts variable definitions stored in a map into a flat list,
+ * respecting their `order` property if set, and sorting by display name otherwise.
+ */
+declare function variablesToList(variables: Record<string, MeshDataVariableDefinition> | undefined): Array<DataVariableDefinitionWithName>;
+
+type VariableSourceGroup = {
+    name: string | undefined;
+    variables: Array<DataVariableDefinitionWithName>;
+};
+/**
+ * Groups variable definitions by their `source` property, and sorts the groups using `variablesToList`.
+ * Returns a flat list of groups and variables. Groups are sorted alphabetically.
+ */
+declare function variablesToGroupedList(variables: Record<string, MeshDataVariableDefinition> | undefined): Array<VariableSourceGroup>;
+
+type EditVariableCommandArguments = {
+    /** Lexical node key that is being edited */
+    sourceKey: string | undefined;
+    /** The variable reference to edit */
+    reference: string;
+};
+type InsertVariableCommandArguments = {
+    reference: string;
+    /**
+     * Optionally pass in display name if you have it
+     * avoids a flash of the reference name
+     */
+    initialDisplayName?: string;
+    /**
+     * If specified, the lexical node with this key is overwritten by the insert.
+     * If unspecified, the current selection is overwritten, or inserted to if a single location.
+     */
+    targetKey: string | undefined;
+};
+/** Opens the variable editor for an existing variable node */
+declare const EDIT_VARIABLE_COMMAND: lexical.LexicalCommand<EditVariableCommandArguments>;
+/** Inserts a new variable node at the current selection, or replacing a specific node key */
+declare const INSERT_VARIABLE_COMMAND: lexical.LexicalCommand<InsertVariableCommandArguments>;
+type VariablesPluginProps<TEditorContext = unknown> = {
+    /** Disables adding variable references via autocomplete. Any existing variables will be rendered as variables. */
+    disableVariables?: boolean;
+    /** Enables 'add variable' option in autocomplete */
+    showAddVariableMenuOption?: boolean | string;
+    /** Enables clicking a variable reference to edit the variable */
+    enableEditingVariables?: boolean;
+    /** Computes the editor context when a variable is added or edited from this composer */
+    getEditorContext?: () => TEditorContext;
+};
+type UseVariablesMenuInput = Pick<VariablesPluginProps, 'showAddVariableMenuOption' | 'enableEditingVariables'>;
+type OnVariableSelectInput = {
+    value: string;
+    queryString?: string;
+    nodeToReplace?: LexicalNode;
+    editor: LexicalEditor;
+};
+type UseVariablesMenu = (input: UseVariablesMenuInput) => {
+    groupedVariables: VariableSourceGroup[];
+    menuOptions: MenuOption[];
+    onSelect: (input: OnVariableSelectInput) => void;
+};
+/** Hook to use the lexical variables typeahead/dropdown menu */
+declare const useVariablesMenu: UseVariablesMenu;
+/**
+ * Enables variables auto-complete and reference management to a Lexical editor.
+ * Must also activate the VariableNode node to make this work.
+ */
+declare function VariablesPlugin<TEditorContext = unknown>({ disableVariables, showAddVariableMenuOption, enableEditingVariables, getEditorContext, }: VariablesPluginProps<TEditorContext>): JSX.Element | null;
+
+type PasteTransformerPluginProps = {
+    /**
+     * Transforms pasted contents before inserting them.
+     * Return undefined to execute default paste behaviour, or a string to set the paste's contents.
+     */
+    transformPaste?: (pastedText: string) => string | undefined;
+};
+
+type UseInputVariablesStateProps<TEditorContext = unknown> = {
+    /**
+     * Sets the value of the input
+     * NOTE: this is NOT reactive after mount
+     */
+    value: string | undefined;
+    /** Callback to receive changes to the value of the variables input */
+    onChange: (newValue: string | undefined) => void;
+    /**
+     * The value to set the field to when it's "reset" from a variables-input to a custom component.
+     * Defaults to undefined.
+     */
+    valueToResetTo?: string | undefined;
+    /** Disables using variables in the input */
+    disableVariables?: boolean;
+    /**
+     * Enables adding variables from the menu. If a string is passed,
+     * the option is enabled and the string is used as the menu label.
+     */
+    showAddVariableMenuOption?: boolean | string;
+    /**
+     * When no variables are referenced in the value, and this prop is provided,
+     * the variables-injection input will be replaced with this component.
+     *
+     * NOTE: When this prop is provided, the and a variable is inserted, any existing value
+     * in the input will be replaced with the variable reference. Once in variables-mode, additional
+     * insertions are inserted at the current selection (or end) of the variables value.
+     */
+    inputWhenNoVariables?: JSX.Element;
+    /** Computes the editor context when a variable is added or edited from this composer */
+    getEditorContext?: () => TEditorContext;
+};
+
+type InputVariablesProps<TEditorContext = unknown> = {
+    /** Sets a HTML ID for the variables input and label */
+    id?: string;
+    /** Enables a label for the input */
+    label?: string;
+    /** sets the input aria-label value. */
+    'aria-label'?: string;
+    /**
+     * Turns off the 'Reset' menu option that is added when:
+     * - inputWhenNoVariables is passed in
+     * - variables are, or have have been bound to
+     *
+     * The reset button returns the editor to the inputWithNoVariables state
+     *
+     * @deprecated this is ignored if passed, computation is now automatic
+     */
+    disableReset?: boolean;
+    /** Enables mutliple lines in the input (\n in the value) */
+    multiLine?: boolean;
+    /** Disables the inline variable selection menu when rendering a variables input */
+    disableInlineMenu?: boolean;
+    /**
+     * Enables clicking a variable reference to edit the variable
+     * Note: automatically disabled if `disabled` or `disableVariables` is set
+     */
+    enableEditingVariables?: boolean;
+    /** (optional) sets and shows the the error message value */
+    errorMessage?: string;
+    /** (optional) sets and shows the the warning message value */
+    warningMessage?: string;
+    /** (optional) sets and shows the the info message value */
+    infoMessage?: string;
+    /** (optional) sets caption text value */
+    caption?: string;
+    /** Disables editing the value of the input, editing variables, and adding variables */
+    disabled?: boolean;
+    /** Sets the test ID of the input */
+    'data-test-id'?: string;
+    /**
+     * Optional ref to get a handle to the variables editor.
+     * This can be useful for situations such as:
+     * * Once initially set, `value` prop is no longer reactive and the editor owns its state. The ref can be used to set the editor state after load.
+     * * Performing other custom mutations to the variables editor, such as inserting text from a button click.
+     */
+    editorRef?: MutableRefObject<LexicalEditor | null>;
+} & PasteTransformerPluginProps & UseInputVariablesStateProps<TEditorContext>;
+/**
+ * An input box that enables insertion of 'variables', provided by VariablesProvider,
+ * into its value.
+ */
+declare function InputVariables<TEditorContext = unknown>(props: InputVariablesProps<TEditorContext>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ParameterConnectionIndicatorProps = {
+    disabled?: boolean;
+    value: unknown;
+    children: ReactNode;
+    menuOptions: ReactNode;
+};
+/**
+ * An input box that enables insertion of 'variables', provided by VariablesProvider,
+ * into its value. Designed specifically for use in the Canvas Parameter Editor.
+ */
+declare function ParameterConnectionIndicator({ children, value, menuOptions, disabled, }: ParameterConnectionIndicatorProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ParameterOrSingleVariableProps<TEditorContext = unknown> = {
+    disabled?: boolean;
+    inputWhenNoVariables: JSX.Element;
+    enableEditingVariables?: boolean;
+} & Omit<UseInputVariablesStateProps<TEditorContext>, 'inputWhenNoVariables'>;
+/**
+ * A parameter which can be one of a custom parameter editor (`inputWhenNoVariables`),
+ * or one single variable value (not multiple). Use for parameters which can only have one variable value,
+ * possibly because they bind to objects or arrays.
+ * Designed visually for use in the Canvas Parameter Editor.
+ */
+declare function ParameterOrSingleVariable<TEditorContext = unknown>(props: ParameterOrSingleVariableProps<TEditorContext>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ParameterVariablesProps<TEditorContext = unknown> = {
+    /** sets the input aria-label value. */
+    'aria-label'?: string;
+    /** Sets the test ID of the input */
+    'data-test-id'?: string;
+    /**
+     * Enables mutliple lines in the input (\n in the value).
+     * If a number is passed, the height of the editor is set to that number of lines and overflow scrolls.
+     * If a boolean true is passed, the editor auto-sizes to the content.
+     */
+    multiLine?: boolean | number;
+    /** Disables editing the value of the input, editing variables, and adding variables */
+    disabled?: boolean;
+    /**
+     * Optional ref to get a handle to the variables editor.
+     * This can be useful for situations such as:
+     * * Once initially set, `value` prop is no longer reactive and the editor owns its state. The ref can be used to set the editor state after load.
+     * * Performing other custom mutations to the variables editor, such as inserting text from a button click.
+     */
+    editorRef?: MutableRefObject<LexicalEditor | null>;
+} & UseInputVariablesStateProps<TEditorContext>;
+/**
+ * An input box that enables insertion of 'variables', provided by VariablesProvider,
+ * into its value. Designed visually for use in the Canvas Parameter Editor.
+ */
+declare function ParameterVariables<TEditorContext = unknown>(props: ParameterVariablesProps<TEditorContext>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type VariableEditorProps<TEditorContext = unknown> = {
+    variable: string;
+    onSubmit: (values: DataVariableDefinitionWithName) => void | Promise<void>;
+    /** Disables the tip about Mesh integrations. Intended for use when this is placed on a custom Mesh integration to edit variables. */
+    disableMeshTip?: boolean;
+    onCancel: () => void;
+    context: TEditorContext | undefined;
+};
+declare function VariableEditor({ variable, onSubmit, onCancel, disableMeshTip }: VariableEditorProps<any>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type VariablesProviderProps<TEditVariableContext = unknown> = React$1.PropsWithChildren<{
+    /**
+     * Signals that components in this variables context are not intended to allow mutation
+     * of the variable values (i.e. editing, adding, or deleting variable definitions).
+     *
+     * Dispatching updates is still accepted, but will be ignored.
+     */
+    readOnly?: boolean;
+    /** Variable values to load into the context */
+    value: Record<string, MeshDataVariableDefinition>;
+    /** Function to handle mutations to the variable values (optional when readOnly is true) */
+    onChange?: (newValue: Record<string, MeshDataVariableDefinition>) => void;
+    /**
+     * Provide a component to handle editing a variable definition (e.g. a modal wrapper)
+     * If not passed, the editor will be rendered inline, with potentially strange results.
+     */
+    editVariableComponent?: React$1.ComponentType<VariableEditorProps<TEditVariableContext>>;
+}>;
+type VariablesAction<TEditVariableContext> = {
+    type: 'edit';
+    variable: string;
+    /** Context that will be passed in a prop to the variables context editing component */
+    context?: TEditVariableContext;
+} | {
+    type: 'remove';
+    variable: string;
+} | {
+    type: 'set';
+    variable: DataVariableDefinitionWithName;
+    openEditor?: boolean;
+    /** Context that will be passed in a prop to the variables context editing component. Only has an effect when openEditor = true */
+    context?: TEditVariableContext;
+} | {
+    type: 'reorder';
+    result: Record<string, DataVariableDefinitionWithName>;
+} | {
+    type: 'cancelEdit';
+};
+type VariablesUpdateEvent = {
+    name: string;
+    latestValue: Record<string, MeshDataVariableDefinition>;
+};
+type VariablesEvents = {
+    update: VariablesUpdateEvent;
+};
+type VariablesContext<TEditVariableContext> = {
+    /**
+     * Signals that components in this variables context are not intended to allow mutation
+     * of the variable values (i.e. editing, adding, or deleting variable definitions).
+     *
+     * Dispatching updates is still accepted, but will be ignored.
+     */
+    readOnly?: boolean;
+    /** Dispatch update events to the variables */
+    dispatch: (event: VariablesAction<TEditVariableContext>) => void;
+    /** The current variables value */
+    variables: Readonly<Record<string, MeshDataVariableDefinition>>;
+    /** Whether the context is editing a variable value currently */
+    isEditing: boolean;
+    /** Add event handles (don't forget to unhook) */
+    events: Emitter<VariablesEvents>;
+    /** Whether the context is backed by a provider, or is just a readonly fake */
+    canDispatch: boolean;
+    /**
+     * A flattened version of `variables` that is a plain key-value object.
+     * Used when binding the variables to a value.
+     */
+    flatVariables: Readonly<Record<string, unknown>>;
+};
+declare function VariablesProvider<TEditComponentContext = never>({ value, onChange, editVariableComponent, readOnly, children, }: VariablesProviderProps<TEditComponentContext>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+declare function useVariables<TEditComponentContext = unknown>(returnEmptyWithoutProvider?: boolean): VariablesContext<TEditComponentContext>;
+
+declare function useOnVariableUpdated(fn: (event: VariablesUpdateEvent) => void, disabled?: boolean): void;
+
+/** Converts a connected data map entry to a VariablesProvider-format variable */
+declare function convertConnectedDataToVariable(bindExpression: string, value: unknown): MeshDataVariableDefinition;
+
+declare function deserializeVariablesEditorState(serialized: string | undefined): string;
+
+declare function prettifyBindExpression(bindExpression: string): string;
+
+/**
+ * Serializes a Lexical variables-editor state (as a Lexical AST) to a Uniform-variable-reference formatted string
+ * Note: if no content is in the editor state, undefined will be returned.
+ */
+declare function serializeVariablesEditorState(editorState: EditorState): string | undefined;
+
+declare function variableDefaultTextValue(defaultValue: unknown): string;
+
+/**
+ * Expected prefix for variable expressions
+ * @deprecated
+ */
+declare const variablePrefix = "${";
+/**
+ * Expected suffix for variable expressions
+ * @deprecated
+ */
+declare const variableSuffix = "}";
+
+declare function VariablesList(): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type DataResourceVariablesListProps = {
+    /**
+     * Overrides rendering of a variable based on the `type` property it has set on it.
+     * If this is not passed, all variables are rendered using TextVariableRenderer.
+     */
+    typeRenderers?: Record<string, ComponentType<DataResourceVariableRendererProps> | undefined>;
+    /**
+     * Callback when the state changes in the data resource variables.
+     * Can be sent directly to `useMeshLocation`'s `setValue` or intercepted for validation
+     * by `createLocationValidator`.
+     */
+    setVariables: SetLocationValueDispatch<DataResourceVariables>;
+    /**
+     * Component that is rendered if no variables are set on the data resource.
+     * Defaults to a callout stating that no settings are required.
+     */
+    noVariables?: ComponentType;
+};
+/**
+ * Renders a list of Data Type-provided variables that can be set on a Data Resource.
+ * Intended to provide a solid base for data resource editors that need to edit a list of variables.
+ * Using the optional `type` attribute of variables, one can use custom components to render different
+ * variables using this component, enabling flexibility for more than just text inputs.
+ */
+declare function DataResourceVariablesList(props: DataResourceVariablesListProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+/**
+ * Renders a list of Data Type-provided variables that can be set on a Data Resource.
+ *
+ * This is a version of DataResourceVariablesList that does not use any Mesh context data.
+ * For most uses you will want to use DataResourceVariablesList instead.
+ */
+declare function DataResourceVariablesListExplicit({ setVariables, noVariables: NoVariablesComponent, typeRenderers, dataType, dynamicInputs, value, }: DataResourceVariablesListProps & {
+    value: DataResourceVariables;
+    dataType: DataType;
+    dynamicInputs: DynamicInputs;
+}): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+type DataResourceVariableRendererProps = {
+    /** Current value of the variable on the data resource */
+    value: string | undefined;
+    /** Updates the value of the variable on the data resource */
+    setValue: (newValue: string | undefined) => void;
+    /** The definition of the data variable */
+    definition: DataVariableDefinitionWithName;
+};
+/** Default data resource variable renderer, uses a text input that supports dynamic input binding */
+declare function TextVariableRenderer({ definition, value, setValue }: DataResourceVariableRendererProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type DataSourceEditorProps = PropsWithChildren<{
+    /**
+     * Callback when the state changes in the request or variables contexts.
+     * Can be sent directly to `useMeshLocation`'s `setValue` or intercepted for validation
+     * by `createLocationValidator`.
+     */
+    onChange: SetLocationValueDispatch<DataSourceLocationValue>;
+} & Pick<VariablesProviderProps, 'editVariableComponent'>>;
+/**
+ * Wrapper for editing a data source using Uniform Mesh SDK components that rely on `useRequest()`
+ * or `useVariables()`, or custom components that use the same hooks.
+ */
+declare function DataSourceEditor({ onChange, children, editVariableComponent }: DataSourceEditorProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type DataTypeEditorProps = PropsWithChildren<{
+    /**
+     * Callback when the state changes in the request or variables contexts.
+     * Can be sent directly to `useMeshLocation`'s `setValue` or intercepted for validation
+     * by `createLocationValidator`.
+     */
+    onChange: SetLocationValueDispatch<DataTypeLocationValue>;
+} & Pick<VariablesProviderProps, 'editVariableComponent'>>;
+/**
+ * Wrapper for editing a data type using Uniform Mesh SDK components that rely on `useRequest()`
+ * or `useVariables()`, or custom components that use the same hooks.
+ */
+declare function DataTypeEditor({ onChange, children, editVariableComponent }: DataTypeEditorProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type MeshAppProps = {
+    loadingComponent?: React__default.ComponentType;
+    errorComponent?: React__default.ComponentType<{
+        error: Error;
+    }>;
+};
+declare const MeshApp: React__default.FC<React__default.PropsWithChildren<MeshAppProps>>;
+
+type DataRefreshButtonProps = HTMLAttributes<HTMLButtonElement> & {
+    /** sets the button text */
+    buttonText: string;
+    /** shows or hides the loading indicator when retrieving data */
+    isLoading: boolean;
+    /** sets the onClick function */
+    onRefreshData: () => void;
+};
+/**
+ * @description The data refresh button is a UI component to indicate to users a request for data is taking place
+ * @example <DataRefreshButton buttonText="my button" isLoading /> */
+declare const DataRefreshButton: ({ buttonText, isLoading, onRefreshData, ...props }: DataRefreshButtonProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchContainerProps = {
+    /**
+     * Adds a label to the search container.
+     */
+    label?: string;
+    /**
+     * Enables a dynamic input connect button to connect a dynamic input to the selected result ID
+     * Prerequisites:
+     * - label must be set
+     * - wrapped in DataResourceDynamicInputProvider
+     */
+    enableDynamicInputToResultId?: boolean;
+    /** a child node that places components within the search location */
+    searchFilters: ReactNode;
+    /** a child node that places components within a scrollable list location */
+    resultList?: ReactNode;
+    /** allows any child element */
+    children?: ReactNode;
+};
+/**
+ * @description Object search container is an opinionated layout for search parameters and retrieved results
+ * @example  <ObjectSearchContainer searchFilters={<>your component</>} resultList={<>your result list component<>} onSave={yourSaveAction} onCancel={yourCancelAction} /> */
+declare const ObjectSearchContainer: ({ label, enableDynamicInputToResultId, searchFilters, resultList, children, }: ObjectSearchContainerProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchFilterProps = {
+    /** shows or hides the required content type select option */
+    requireContentType?: boolean;
+    /** sets the text for the required content type select option
+     * @default 'All content types'
+     */
+    typeSelectorAllTypesOptionText?: string;
+    /** sets the select input value label text
+     * @default 'Content Type Select'
+     */
+    selectLabel?: string;
+    /** sets the select input options */
+    selectOptions: Array<{
+        id: string;
+        name?: string;
+        label: string;
+    }>;
+    /** sets the search input name value
+     * @default 'searchText'
+     */
+    searchInputName?: string;
+    /** sets the search input placeholder text
+     * @default 'Enter keyword to narrow your results'
+     */
+    searchInputPlaceholderText?: string;
+};
+/**
+ * @description Object search filter is an opinionated filter that has pre-defined query and setQuery functions
+ * that can be extended with custom fuctions
+ * @example  <ObjectSearchFilter selectOptions={[{ id: 'id value', name: 'name value'}]} /> */
+declare const ObjectSearchFilter: ({ requireContentType, typeSelectorAllTypesOptionText, searchInputName, searchInputPlaceholderText, selectLabel, selectOptions, }: ObjectSearchFilterProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchFilterContainerProps = {
+    /**
+     * sets the title for the container
+     * @deprecated we recommend setting the label on ObjectSearchContainer instead
+     */
+    label?: string;
+    /** sets child components in an opinionated layout */
+    children?: React.ReactNode;
+};
+/**
+ * @description an opinionated layout for search filters
+ * @example <ObjectSearchFilterContainer label="my label"><input type="text" aria-label="my input" /></ObjectSearchFilterContainer>
+ */
+declare const ObjectSearchFilterContainer: ({ label, children }: ObjectSearchFilterContainerProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type SearchQueryProps<TExtraFilters = unknown> = {
+    /** sets the content type in the search context */
+    contentType?: string;
+    /** sets the keyword search in the search context */
+    keyword?: string;
+} & TExtraFilters;
+type SelectedItemProps<TExtraProps = unknown> = {
+    /** sets the id value */
+    id: string;
+    /** sets the title value */
+    title: string;
+    /**
+     * sets the name value, sometimes used for products
+     * @deprecated use title instead
+     */
+    name?: string;
+    /**
+     * sets the subtitle value
+     * @deprecated this is unused
+     */
+    subtitle?: string;
+    /** sets the content type value */
+    contentType?: string | string[];
+    /** sets the created date value using TimeAgo to transform the date */
+    createdAt?: TDate;
+    /** sets the image src */
+    imageUrl?: string;
+    /** sets the link icon */
+    editLinkIcon?: string | React.ComponentType<{
+        className?: string;
+    }>;
+    /** sets the link href value to an external source */
+    editLink?: string;
+    /** sets the published date value using TimeAgo to transform the date */
+    publishedAt?: TDate;
+    /** sets the publish status */
+    publishStatus?: {
+        /** sets the text value of the publish badge */
+        text: string;
+        /** sets the theme value of the publish badge
+         * @default 'unimportant'
+         */
+        theme?: BadgeThemeProps;
+    };
+    /** sets any additional meta data */
+    metadata?: Record<string, string>;
+    /** allows for child react elements to be nested in the popover */
+    popoverData?: ReactNode;
+    /** disable or enable drag and drop functionality */
+    disableDnD?: boolean;
+} & TExtraProps;
+type ItemListProps<TListItemExtraProps = unknown> = {
+    items?: Array<SelectedItemProps<TListItemExtraProps>>;
+};
+type ObjectSearchContextProps<TExtraFilters = unknown, TExtraItemProps = unknown> = {
+    /** function that updates / sets the search query state */
+    onSetQuery: (value: SearchQueryProps<TExtraFilters>) => void;
+    /** current search query state */
+    query: SearchQueryProps<TExtraFilters>;
+    /**
+     * When dynamic inputs are used, this is the query with any dynamic input values expanded
+     * This is the value you'd want to send to a query endpoint to fetch; `query` will possibly
+     * have dynamic input values that haven't been expanded yet.
+     */
+    boundQuery: SearchQueryProps<TExtraFilters>;
+    /** function that sets the selected items to state */
+    onSelectItem: (selectedResult: SelectedItemProps<TExtraItemProps> | Array<SelectedItemProps<TExtraItemProps>>) => void;
+    /** function that clears all selected items from state */
+    onRemoveAllSelectedItems: () => void;
+    /** current selected items in state */
+    selectedListItems: Array<SelectedItemProps<TExtraItemProps>>;
+    /** current list of results in state */
+    list: ItemListProps<TExtraItemProps>;
+    /** function that sets the list of items to state */
+    onSetList: (value: ItemListProps) => void;
+};
+type ObjectSearchProviderProps = {
+    children: ReactNode;
+    currentlySelectedItems?: Array<SelectedItemProps>;
+};
+declare const ObjectSearchProvider: ({ currentlySelectedItems, children }: ObjectSearchProviderProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+declare function useObjectSearchContext<TExtraSearchFilters = unknown, TExtraItemProps = unknown>(): ObjectSearchContextProps<TExtraSearchFilters, TExtraItemProps>;
+
+type ObjectSearchListItemProps = SelectedItemProps & {
+    /** sets the content type value, this is normally used for subtitles e.g. Kitchens  */
+    contentType?: string | string[];
+    /** sets image parameters */
+    image?: {
+        /** sets the src valuue */
+        src: string;
+        /** sets the alt text value */
+        alt: string;
+        /** set the width attribute of the image
+         * if both width and height are set the image loading attribute is set to `lazy`
+         */
+        width?: number;
+        /** set the height attribute of the image
+         * if both width and height are set the image loading attribute is set to `lazy`
+         */
+        height?: number;
+    };
+    /** sets the function call on the role="button" wrapping element */
+    onSelect?: (data?: Record<string, unknown>) => void;
+    /** allows child components within the popover data  */
+    popoverData?: React$1.ReactNode;
+    /** allows authors to add any child component that is not controlled by Uniform */
+    children?: React$1.ReactNode;
+    /** sets whether multiple entries can be added to the results list context
+     * @default false
+     */
+    isMulti?: boolean;
+    /** sets disabled state to the interactive element */
+    disabled?: boolean;
+};
+/**
+ * @description entry search list item is an opinionated UI component best used for initial retrieved results
+ * @example <ObjectSearchListItem  id="my-result-item" title="title" popoverData={<p>some data info</p>}><div>example of uncontrolled content</div></ObjectSearchListItem> */
+declare const ObjectSearchListItem: ({ id, title, contentType, image, popoverData, onSelect, isMulti, disabled, children, }: ObjectSearchListItemProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+/**
+ * An opinionated loading skeleton component best used with ObjectSearchListItem
+ * @example <ObjectSearchListItemLoadingSkeleton />
+ */
+declare const ObjectSearchListItemLoadingSkeleton: () => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchResultItemProps = SelectedItemProps & {
+    /** sets additional remove functionality onto of default removal */
+    onRemove?: () => void;
+    /** sets whether to show or hide the remove button
+     * @default false
+     */
+    hideRemoveButton?: boolean;
+    /** sets user defined child nodes that are uncontrolled by Uniform */
+    children?: ReactNode;
+    /** disable or enable drag and drop functionality
+     * @default false
+     */
+    disableDnD?: boolean;
+};
+/**
+ * @description An opinionated result item, best used for selected results
+ * @example <ObjectSearchResultItem id="my-result" title="title" />
+ */
+declare const ObjectSearchResultItem: ({ id, title, name, contentType, popoverData, publishStatus, editLinkIcon, editLink, imageUrl, onRemove, createdAt, publishedAt, hideRemoveButton, disableDnD, children, }: ObjectSearchResultItemProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchResultItemButtonProps<THtml extends HTMLAttributes<HTMLElement> = HTMLAttributes<HTMLButtonElement>> = {
+    /** sets the button or link text value */
+    text: string;
+    /** sets the button or link icon */
+    icon?: string | React.ComponentType<{
+        className?: string;
+    }>;
+} & THtml;
+/**
+ * @description An opinionated button component best used within the ObjectSearchResultItem component
+ * @example <ObjectSearchResultItemButton text="button text" icon="/my-image.png" onClick={() => myFunction()} />
+ */
+declare const ObjectSearchResultItemButton: ({ text, icon, ...props }: ObjectSearchResultItemButtonProps<HTMLAttributes<HTMLButtonElement>>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+/**
+ * @description An opinionated link component styled the same of the ObjectSearchResultItemButton component,
+ * that automatically sets the target and rel attributes. Best used within the ObjectSearchResultItem component
+ * @example <LinkButton text="link text" icon="/my-image.png" />
+ */
+declare const LinkButton: ({ text, icon, ...props }: ObjectSearchResultItemButtonProps<Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'target' | 'rel'>>) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ObjectSearchResultListProps<TRenderComponent extends SelectedItemProps = SelectedItemProps> = {
+    /** sets the result label value
+     * @default 'Selected'
+     */
+    resultLabelText?: string;
+    /** sets the on remove button click action */
+    onRemoveAllSelected?: () => void;
+    /** sets the remove button text
+     * @default 'Remove all'
+     */
+    removeButtonText?: string;
+    /** sets whether to show or hide the remove button
+     * @default false
+     */
+    hideRemoveButton?: boolean;
+    /** allows additional buttons to be added to the result title group */
+    additionalButtons?: React.ReactNode;
+    /** allows placing child components within the result list area */
+    renderResultComponent?: (value: TRenderComponent) => React.ReactNode;
+    /** disable or enable drag and drop functionality
+     * @default false
+     */
+    disableDnD?: boolean;
+    /** sets the draggable id value */
+    multiSelectId?: string;
+    /** Rendered when nothing is selected */
+    whenNothingSelected?: React.ReactNode;
+};
+/**
+ * @description An opinionated result list UI component that has built in drag and drop functionality and removal of all selected items from context.
+ * The result item component defaults to <ObjectSearchResultItem {...props} />, however this can be overridden with any other UI component and still
+ * maintain drag and drop functionality
+ * @example <ObjectSearchResultList id="my-id" title="title" renderResultComponent={(values) => <CustomComponent {...values} />} />
+ */
+declare function ObjectSearchResultList<TRenderComponent extends SelectedItemProps = SelectedItemProps>({ resultLabelText, removeButtonText, onRemoveAllSelected, hideRemoveButton, additionalButtons, renderResultComponent, multiSelectId, disableDnD, whenNothingSelected, }: ObjectSearchResultListProps<TRenderComponent>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type QueryFilterSearchProps = {
+    /** sets the count value */
+    count: number | string;
+    /** sets the sortBy filter value */
+    sortBy: string;
+    /** sets the sortOrder filter value */
+    sortOrder: string;
+};
+type QuertFilterSelectionOptionProps = Array<{
+    id: string;
+    name: string;
+    label: string;
+}>;
+type QueryFilterProps<TSelectOptions extends QuertFilterSelectionOptionProps = QuertFilterSelectionOptionProps> = {
+    /** sets the query filter title
+     * @default 'Configure Query'
+     */
+    queryFilterTitle?: string;
+    /** sets the content type all selected options label
+     * @default 'All content types'
+     */
+    typeSelectorAllTypesOptionText?: string;
+    /** sets the content type label value
+     * @default 'Filter by content type'
+     */
+    contentTypeLabel?: string;
+    /** sets the content type select options */
+    contentTypeOptions: TSelectOptions;
+    /** sets whether the content type filter is required */
+    requireContentType?: boolean;
+    /** sets the count label value
+     * @default 'Count'
+     */
+    countLabel?: string;
+    /** sets the count value or items to show
+     * @default 5
+     */
+    countValue?: number;
+    /** sets the sort label text
+     * @default 'Sort'
+     */
+    sortLabel?: string;
+    /** sets the sort select options value */
+    sortOptions: TSelectOptions;
+    /** sets the sort order lable value
+     * @default 'Sort Order'
+     */
+    sortOrderLabel?: string;
+    /** sets the sort order select options value */
+    sortOrderOptions: TSelectOptions;
+    /** sets the search input name value
+     * @default 'searchText'
+     */
+    searchInputName?: string;
+    /** sets the search input placeholder text
+     * @default 'Enter keyword to narrow your results'
+     */
+    searchInputPlaceholderText?: string;
+    /** sets the label for the search input
+     * @default 'Query'
+     */
+    searchInputLabel?: string;
+    /** allows for additional child components, for example more input components */
+    children?: ReactNode;
+};
+/**
+ * @description An opinionated multi query filter UI component, best used for querying product data or more complex scenarios
+ * @example <QueryFilter contentTypeOptions={[{ id: 'id', name: 'name' }]} sortOptions={[{ id: 'id', name: 'name' }]} sortOrderOptions={[{ id: 'id', name: 'name' }]} />
+ */
+declare const QueryFilter: ({ requireContentType, queryFilterTitle, contentTypeLabel, typeSelectorAllTypesOptionText, contentTypeOptions, searchInputName, searchInputPlaceholderText, searchInputLabel, countLabel, countValue, sortLabel, sortOptions, sortOrderLabel, sortOrderOptions, children, }: QueryFilterProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type ParamTypeDynamicDataProviderProps = {
+    /** Child components of the provider. Variables-using components, such as ParameterVariables, can be used here. */
+    children: ReactNode;
+};
+/** Context to tell the binding UI what types are allowed for the current binding expression */
+type ParameterConnectOptions = {
+    /**
+     * Which JSON primitive types can be connected to this parameter.
+     * Note that if the only value of the parameter is a complex data element connection (object or array), then the connected data will be the literal value, not a string.
+     */
+    connectsTo: BindableTypes[];
+};
+/**
+ * Wrapper for data resource locations. Provides read-only access to dynamic inputs as if they were variables,
+ * using variables-aware components (i.e. InputVariables). This simplifies building dynamic-input-aware editors,
+ * where a data resource variable could be a static value or bound to a dynamic input from the route (project map).
+ */
+declare function ParamTypeDynamicDataProvider(props: ParamTypeDynamicDataProviderProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/** Editor component to let you write a request body for POST requests */
+declare function RequestBody(): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/** Editor component to manage HTTP headers on a request */
+declare function RequestHeaders({ disableVariables }: Pick<InputVariablesProps, 'disableVariables'>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/** Dropdown to pick a HTTP method for a request */
+declare function RequestMethodSelect(props: Omit<InputSelectProps, 'value' | 'onChange' | 'options'>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type RequestParametersProps = Pick<InputVariablesProps, 'disableVariables'>;
+/** Component to manage query parameters on a request */
+declare function RequestParameters({ disableVariables }: Pick<InputVariablesProps, 'disableVariables'>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type RequestParameter = {
+    key: string;
+    value: string;
+};
+type BaseRequestData = {
+    baseUrl: string;
+    headers?: Array<RequestParameter>;
+    parameters?: Array<RequestParameter>;
+};
+type RequestData = {
+    relativeUrl: string;
+    headers: Array<RequestParameter>;
+    parameters: Array<RequestParameter>;
+    baseRequest?: BaseRequestData;
+    method?: string;
+    body?: string;
+};
+type RequestProviderProps = React$1.PropsWithChildren<{
+    value: RequestData;
+    onChange: (delegate: (oldValue: RequestData) => RequestData) => void;
+}>;
+type RequestAction = {
+    type: 'setRelativeUrl';
+    relativeUrl: string;
+} | {
+    type: 'updateHeader';
+    header: RequestParameter;
+    index?: number;
+} | {
+    type: 'removeHeader';
+    index: number;
+} | {
+    type: 'updateParameter';
+    parameter: RequestParameter;
+    index?: number;
+} | {
+    type: 'removeParameter';
+    index: number;
+} | {
+    type: 'setMethod';
+    method: string;
+} | {
+    type: 'setBody';
+    body: string;
+    contentType: string;
+};
+type RequestContext = {
+    dispatch: (event: RequestAction) => void;
+    request: Readonly<RequestData>;
+};
+/** Provides a mutable HTTP request object context. Components such as RequestBody and RequestUrl use this context to render. */
+declare function RequestProvider({ value, onChange, children }: RequestProviderProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+declare function useRequest(): RequestContext;
+
+type RequestTypeContainerProps = React$1.HTMLAttributes<HTMLDivElement> & {
+    /**sets the background color of the container
+     * @default 'transparent'
+     */
+    bgColor?: 'transparent' | 'var(--gray-100)';
+    children: React$1.ReactNode;
+};
+/**
+ * @description a container to layout content in a 2 column grid format = 12ch 1fr
+ * @example <RequestTypeContainer bgColor="var(--gray-100)">
+ * <label>Name <input type="text" /></label>
+ * <label>Name <input type="text" /></label>
+ * </div> */
+declare const RequestTypeContainer: ({ bgColor, children, ...props }: RequestTypeContainerProps) => _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/**
+ * Displays the current full URL of the request, including the base URL if one is set
+ */
+declare function RequestUrl(): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/**
+ * Editor to modify the current URL of the request
+ * Note: entering query string parameters automatically converts them and syncs the request state with them
+ */
+declare function RequestUrlInput(props: Omit<InputVariablesProps, 'value' | 'onChange'> & Pick<InputVariablesProps, 'showAddVariableMenuOption' | 'enableEditingVariables'>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare function urlEncodeRequestUrl(url: string, varValues?: Record<string, MeshDataVariableDefinition>): string;
+declare function urlEncodeRequestParameter(parameter: RequestParameter, varValues?: Record<string, MeshDataVariableDefinition>): RequestParameter;
+
+/**
+ * Hook to make it simple to read and write a specific request header by name,
+ * instead of supporting multiple values in an array like native dispatch.
+ *
+ * NOTE: if multiple values are added for the named header, this hook will bind to the FIRST
+ * instance of the header and leave the other values alone.
+ */
+declare function useRequestHeader(headerName: string): {
+    value: string;
+    update: (value: string) => void;
+};
+
+/**
+ * Hook to make it simple to read and write a specific request query string parameter by name,
+ * instead of supporting multiple values in an array like native dispatch.
+ *
+ * NOTE: if multiple values are added for the named parameter, this hook will bind to the FIRST
+ * instance of the parameter and leave the other values alone.
+ */
+declare function useRequestParameter(paramName: string): {
+    value: string;
+    update: (value: string) => void;
+};
+
+/** Converts connected data map into VariablesProvider-format variables */
+declare function useConnectedDataAsVariables(connectedData: Record<string, unknown> | undefined): Record<string, MeshDataVariableDefinition>;
+
+/** Converts dynamic inputs into VariablesProvider-format variables */
+declare function useDynamicInputsAsVariables(dynamicInputs: MinimalDynamicInputs): Record<string, MeshDataVariableDefinition>;
+
+/**
+ * Provides convenient access to the current Uniform Mesh SDK instance via React hook.
+ * Intended to be used within <MeshApp />.
+ */
+declare function useUniformMeshSdk(): _uniformdev_mesh_sdk.UniformMeshSDK;
+
+/**
+ * Creates a validation interceptor between useMeshLocation's setValue function and your code.
+ * You can use this utility to write cleaner validation logic for your Mesh Location UIs.
+ * @param setValue The location's raw setValue function
+ * @param validate A function to validate the new location's value.
+ * @returns An equivalent to the setValue function that intercepts sets, performs validation, and emits the result with the new value.
+ */
+declare function createLocationValidator<TSetValue>(setValue: SetLocationValueDispatch<TSetValue>, validate: (newValue: TSetValue, currentResult: SetValueOptions | undefined) => SetValueOptions): SetLocationValueDispatch<TSetValue>;
+
+export { $createVariableNode, $isVariableNode, BaseRequestData, Brand, ControlledValuePlugin, DamItem, DamSelectedItem, DamSelectedItemProps, DataRefreshButton, DataRefreshButtonProps, DataResourceDynamicInputProvider, DataResourceDynamicInputProviderProps, DataResourceVariableRendererProps, DataResourceVariablesList, DataResourceVariablesListExplicit, DataResourceVariablesListProps, DataSourceEditor, DataSourceEditorProps, DataTypeEditor, DataTypeEditorProps, DataVariableDefinitionWithName, DefaultSearchRow, DefaultSelectedItem, DispatchResult, EDIT_VARIABLE_COMMAND, EditVariableCommandArguments, EntrySearch, EntrySearchContentType, EntrySearchProps, EntrySearchQueryOptions, EntrySearchResult, EntrySearchRowProps, EntrySearchSelectedItemProps, GetProductOptions, GetProductsOptions, INSERT_VARIABLE_COMMAND, index as Icons, InputVariables, InputVariablesProps, InsertVariableCommandArguments, ItemListProps, LinkButton, MeshApp, MeshAppProps, MeshDataVariableDefinition, MinimalDynamicInput, MinimalDynamicInputs, NoResultsProps, ObjectSearchContainer, ObjectSearchContainerProps, ObjectSearchContextProps, ObjectSearchFilter, ObjectSearchFilterContainer, ObjectSearchFilterContainerProps, ObjectSearchFilterProps, ObjectSearchListItem, ObjectSearchListItemLoadingSkeleton, ObjectSearchListItemProps, ObjectSearchProvider, ObjectSearchProviderProps, ObjectSearchResultItem, ObjectSearchResultItemButton, ObjectSearchResultItemButtonProps, ObjectSearchResultItemProps, ObjectSearchResultList, ObjectSearchResultListProps, ParamTypeDynamicDataProvider, ParamTypeDynamicDataProviderProps, ParameterConnectOptions, ParameterConnectionIndicator, ParameterConnectionIndicatorProps, ParameterOrSingleVariable, ParameterOrSingleVariableProps, ParameterVariables, ParameterVariablesProps, ProductCategory, ProductDynamicSelectorValue, ProductPreviewList, ProductQuery, ProductQueryCategory, ProductQueryContext, ProductQueryContextValue, ProductQueryProps, ProductSearch, ProductSearchContext, ProductSearchContextValue, ProductSearchProps, ProductSearchResult, ProductSearchResults, ProductSearchRow, ProductSelectedItem, QueryFilter, QueryFilterProps, QueryFilterSearchProps, RequestAction, RequestBody, RequestContext, RequestData, RequestHeaders, RequestMethodSelect, RequestParameter, RequestParameters, RequestParametersProps, RequestProvider, RequestProviderProps, RequestTypeContainer, RequestTypeContainerProps, RequestUrl, RequestUrlInput, ResolvableLoadingValue, SearchQueryProps, SelectedItemProps, SelectionField, SelectionFieldValue, SerializedVariableNode, SetLocationValueDispatch, SetLocationValueFunction, TextVariableRenderer, UseVariablesMenu, UseVariablesMenuInput, VariableEditor, VariableEditorProps, VariableNode, VariableNodeState, VariableSourceGroup, VariablesAction, VariablesContext, VariablesEvents, VariablesList, VariablesPlugin, VariablesPluginProps, VariablesProvider, VariablesProviderProps, VariablesUpdateEvent, badgeIcon, convertConnectedDataToVariable, createLocationValidator, damSelectItemImage, damSelectedItemContainer, damSelectedItemCopy, damSelectedItemDetails, damSelectedItemIcon, damSelectedItemInfoBtn, damSelectedItemInner, damSelectedItemLinkBtn, damSelectedItemLinkContainer, damSelectedItemMediaContainer, damSelectedItemPopover, damSelectedItemPopoverLabel, damSelectedItemSmallText, damSelectedItemTitle, deserializeVariablesEditorState, draggableContainer, draggableIcon, draggableIconOffset, draggableIconWrapper, entrySearchBtn, entrySearchConfig, entrySearchConfigHidden, entrySearchLoadMoreBtn, entrySearchResultList, entrySearchSelectIcon, entrySearchSelectImg, entrySearchSelectInput, entrySearchSelectOption, entrySearchWrapper, prettifyBindExpression, productSearchRowActiveIcon, productSearchRowCategory, productSearchRowContainer, productSearchRowContent, productSearchRowContentActive, productSearchRowDetails, productSearchRowTitle, productSelectedItemContainer, productSelectedItemContent, productSelectedItemDetails, productSelectedItemIcon, productSelectedItemImage, productSelectedItemLinkContainer, productedSelectedItemLinkBtn, productedSelectedItemSmallText, searchRowBtn, searchRowContainer, searchRowContainerActive, searchRowContainerWithPopover, searchRowPopover, searchRowText, searchRowTextSmall, selectItemLinkBtn, selectItemLinkContainer, selectItemPopover, selectItemPopoverLabel, selectItemSmallText, selectedItemContainer, selectedItemCopy, selectedItemDetails, selectedItemIcon, selectedItemInner, selectedItemTitle, serializeVariablesEditorState, urlEncodeRequestParameter, urlEncodeRequestUrl, useConnectedDataAsVariables, useDynamicInputsAsVariables, useMeshLocation, useObjectSearchContext, useOnVariableUpdated, useProductQueryContext, useProductSearchContext, useRequest, useRequestHeader, useRequestParameter, useUniformMeshSdk, useVariables, useVariablesMenu, variableDefaultTextValue, variablePrefix, variableSuffix, variablesToGroupedList, variablesToList };