@uniformdev/mesh-sdk-react 19.35.2 → 19.36.0

package/dist/index.d.mts

@@ -0,0 +1,1163 @@
+import * as _emotion_react_types_jsx_namespace from '@emotion/react/types/jsx-namespace';
+import * as React$1 from 'react';
+import React__default, { SVGProps, PropsWithChildren, ComponentType, HTMLAttributes, ReactNode, 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 } 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';
+
+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 = PropsWithChildren<{
+    /** Explicitly provide dynamic input values. If not set, Mesh location will be used */
+    dynamicInputs?: MinimalDynamicInputs;
+}>;
+/**
+ * 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({ children, dynamicInputs, }: 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;
+};
+
+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 InputToken = {
+    name: string;
+    value: string;
+};
+type InputVariablesProps = {
+    /** 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;
+    /** sets the value of the input */
+    value: string;
+    /** sets the passed down function call */
+    onChange: (newValue: string) => void;
+    /** Disables using variables in the input */
+    disableVariables?: boolean;
+    /**
+     * 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 not usually necessary to set this, it's automatic
+     */
+    disableReset?: boolean;
+    /** Enables adding variables from the menu */
+    showAddVariableMenuOption?: boolean;
+    /** Disables the inline variable selection menu when rendering a variables input */
+    disableInlineMenu?: boolean;
+    /** Enables clicking a variable reference to edit the variable */
+    enableEditingVariables?: boolean;
+    /**
+     * When no variables are referenced in the value, and this prop is provided,
+     * the variables-injection input will be replaced with this component.
+     */
+    inputWhenNoVariables?: JSX.Element;
+    /** (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;
+    /** Sets the test ID of the input */
+    'data-test-id'?: string;
+} & PasteTransformerPluginProps;
+declare function InputVariables({ id, 'aria-label': ariaLabel, label, value, disableVariables, disableReset, enableEditingVariables, disableInlineMenu, onChange, transformPaste, showAddVariableMenuOption, inputWhenNoVariables, caption, errorMessage, warningMessage, infoMessage, 'data-test-id': dataTestId, }: InputVariablesProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+/** Expected prefix for variable expressions */
+declare const variablePrefix = "${";
+/** Expected suffix for variable expressions */
+declare const variableSuffix = "}";
+
+type DataVariableDefinitionWithName = {
+    name: string;
+} & DataVariableDefinition;
+/**
+ * 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, DataVariableDefinition> | undefined): Array<DataVariableDefinitionWithName>;
+
+type VariableEditorProps = {
+    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;
+};
+declare function VariableEditor({ variable, onSubmit, onCancel, disableMeshTip }: VariableEditorProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare function VariablesList(): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+type VariablesProviderProps = 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, DataVariableDefinition>;
+    /** Function to handle mutations to the variable values (optional when readOnly is true) */
+    onChange?: (newValue: Record<string, DataVariableDefinition>) => 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>;
+}>;
+type VariablesAction = {
+    type: 'edit';
+    variable: string;
+} | {
+    type: 'remove';
+    variable: string;
+} | {
+    type: 'set';
+    variable: DataVariableDefinitionWithName;
+    openEditor?: boolean;
+} | {
+    type: 'reorder';
+    result: Record<string, DataVariableDefinitionWithName>;
+};
+type VariablesEvents = {
+    update: string;
+};
+type VariablesContext = {
+    /**
+     * 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) => void;
+    /** The current variables value */
+    variables: Readonly<Record<string, DataVariableDefinition>>;
+    /** 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, string>>;
+};
+declare function VariablesProvider({ value, onChange, editVariableComponent, readOnly, children, }: VariablesProviderProps): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+declare function useVariables(returnEmptyWithoutProvider?: boolean): VariablesContext;
+
+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;
+
+/** 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'>): _emotion_react_types_jsx_namespace.EmotionJSX.Element;
+
+declare function urlEncodeRequestUrl(url: string, varValues?: Record<string, DataVariableDefinition>): string;
+declare function urlEncodeRequestParameter(parameter: RequestParameter, varValues?: Record<string, DataVariableDefinition>): 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;
+};
+
+/**
+ * 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 { BaseRequestData, Brand, DamItem, DamSelectedItem, DamSelectedItemProps, DataRefreshButton, DataRefreshButtonProps, DataResourceDynamicInputProvider, DataResourceDynamicInputProviderProps, DataResourceVariableRendererProps, DataResourceVariablesList, DataResourceVariablesListExplicit, DataResourceVariablesListProps, DataSourceEditor, DataSourceEditorProps, DataTypeEditor, DataTypeEditorProps, DataVariableDefinitionWithName, DefaultSearchRow, DefaultSelectedItem, DispatchResult, EntrySearch, EntrySearchContentType, EntrySearchProps, EntrySearchQueryOptions, EntrySearchResult, EntrySearchRowProps, EntrySearchSelectedItemProps, GetProductOptions, GetProductsOptions, index as Icons, InputToken, InputVariables, InputVariablesProps, ItemListProps, LinkButton, MeshApp, MeshAppProps, MinimalDynamicInput, MinimalDynamicInputs, NoResultsProps, ObjectSearchContainer, ObjectSearchContainerProps, ObjectSearchContextProps, ObjectSearchFilter, ObjectSearchFilterContainer, ObjectSearchFilterContainerProps, ObjectSearchFilterProps, ObjectSearchListItem, ObjectSearchListItemLoadingSkeleton, ObjectSearchListItemProps, ObjectSearchProvider, ObjectSearchProviderProps, ObjectSearchResultItem, ObjectSearchResultItemButton, ObjectSearchResultItemButtonProps, ObjectSearchResultItemProps, ObjectSearchResultList, ObjectSearchResultListProps, 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, SetLocationValueDispatch, SetLocationValueFunction, TextVariableRenderer, VariableEditor, VariableEditorProps, VariablesAction, VariablesContext, VariablesEvents, VariablesList, VariablesProvider, VariablesProviderProps, badgeIcon, createLocationValidator, damSelectItemImage, damSelectedItemContainer, damSelectedItemCopy, damSelectedItemDetails, damSelectedItemIcon, damSelectedItemInfoBtn, damSelectedItemInner, damSelectedItemLinkBtn, damSelectedItemLinkContainer, damSelectedItemMediaContainer, damSelectedItemPopover, damSelectedItemPopoverLabel, damSelectedItemSmallText, damSelectedItemTitle, draggableContainer, draggableIcon, draggableIconOffset, draggableIconWrapper, entrySearchBtn, entrySearchConfig, entrySearchConfigHidden, entrySearchLoadMoreBtn, entrySearchResultList, entrySearchSelectIcon, entrySearchSelectImg, entrySearchSelectInput, entrySearchSelectOption, entrySearchWrapper, 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, urlEncodeRequestParameter, urlEncodeRequestUrl, useMeshLocation, useObjectSearchContext, useProductQueryContext, useProductSearchContext, useRequest, useRequestHeader, useRequestParameter, useUniformMeshSdk, useVariables, variablePrefix, variableSuffix, variablesToList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/mesh-sdk-react",
-  "version": "19.35.2",
+  "version": "19.36.0",
   "description": "Uniform Mesh Framework SDK for React",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./dist/index.js",
@@ -45,8 +45,8 @@
   "dependencies": {
     "@hookform/resolvers": "^3.0.1",
     "@lexical/react": "^0.11.1",
-    "@uniformdev/design-system": "19.35.2",
-    "@uniformdev/mesh-sdk": "19.35.2",
+    "@uniformdev/design-system": "19.36.0",
+    "@uniformdev/mesh-sdk": "19.36.0",
     "lexical": "^0.11.1",
     "mitt": "^3.0.0",
     "react-beautiful-dnd": "13.1.1",
@@ -80,5 +80,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "64d3270175087c87cfaa29a283aa4a7b0a98fd2c"
+  "gitHead": "3ae246a7f0f39adeaf04ecba4c7e48c478c019ad"
 }