import * as _gem_sdk_core from '@gem-sdk/core';
import { BasePropsWrap, TypographySettingV2, ObjectDevices, Background, SizeSettingGlobal, StateProp, ColorValueType, TypographySetting, Border, SizeSetting, CornerRadius, ShadowProps, BackgroundMedia, AlignProp, TransformProp, PageContext, Ratio, ResponsiveStateProp, BackgroundImageValue, ObjectLayoutValue, BaseProps, NameDevices, PaddingType as PaddingType$2, RawChild, PostPurchaseTypo, AlignItemProp, ProductProviderProps, AdvancedType, DotStyle as DotStyle$2, AirProductReview, AliReviewsWidgetType, BogosWidgetType, BoldSubscriptionsWidgetType, FastBundleWidgetType, FeraReviewsWidgetType, FeraReviewsV3WidgetType, GrowaveWidgetTypeV2, GrowaveWidgetTypeV1, JudgeMeReviewsWidgetType, LaiProductReviewsWidgetType, LaiProductReviewsAdvancedWidgetType, LooxReviewsWidgetType, LooxReviewsWidgetTypeV2, OmnisendWidgetType, OpinewWidgetType, OpinewDesignWidgetType, PickyStoryWidgetType, PreOrderNowWodWidgetType, ProductReviewsWidgetType, RivyoWidgetType, RyviuWidgetType, StampedWidgetType, StampedWidgetTypeV2, TagShopWidgetType, TrustooWidgetType, UltimateSalesBoostWidgetType, VitalsWidgetType, WiserWidgetType, WiserV2WidgetType, YotpoReviewsWidgetType, InstantJudgeMeReviewsWidgetType, InstantLooxReviewsWidgetType, ComponentSetting, RenderMode } from '@gem-sdk/core';
import { Property } from 'csstype';
import * as _gem_sdk_keen_slider from '@gem-sdk/keen-slider';
import { KeenSliderInstance } from '@gem-sdk/keen-slider';
import * as _gem_sdk_swiper from '@gem-sdk/swiper';
import { Swiper } from '@gem-sdk/swiper';
import React$1, { ReactNode } from 'react';

type AccordionSettingProps = {
    activeKey?: string;
    childItem?: string[];
    iconSvg?: string;
    iconPosition?: 'left' | 'right';
    expandItem?: boolean;
    titleTypo?: TypographySettingV2;
    typo?: TypographySettingV2;
    background?: ObjectDevices<Background>;
    childConfig?: string[];
    iconGlobalSize?: ObjectDevices<SizeSettingGlobal>;
    iconExpand?: string;
    iconCollapse?: string;
    activeMultiple?: boolean;
    alignment?: ObjectDevices<Property.AlignItems>;
    expandedMode?: string;
    configIconSize?: number;
    iconCollapseSize?: number;
    layoutHeader?: string;
};
type AccordionStyleProps = {
    textColor?: StateProp<ColorValueType>;
    /**
     * @deprecated please use typo
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    bgColor?: StateProp<ColorValueType>;
    color?: StateProp<ColorValueType>;
    iconColor?: StateProp<ColorValueType>;
    headerBorder?: StateProp<Border>;
    align?: ObjectDevices<Property.AlignItems>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    itemHeaderSpacing?: SizeSetting;
    itemContentSpacing?: SizeSetting;
    backgroundContent?: ObjectDevices<ColorValueType>;
    roundedContent?: CornerRadius;
    borderContent?: Border;
    contentSizePadding?: ObjectDevices<SizeSettingGlobal>;
    headerContentPadding?: ObjectDevices<SizeSettingGlobal>;
    widthHeightSize?: ObjectDevices<SizeSettingGlobal>;
    hasActiveShadow?: boolean;
    accordionShadow?: ShadowProps;
    enableHoverEffect?: boolean;
    enableActiveEffect?: boolean;
};
type AccordionTranslateKeys = keyof (AccordionSettingProps & AccordionStyleProps);
type AccordionProps = BasePropsWrap<AccordionSettingProps, AccordionStyleProps> & {
    children?: React.ReactNode;
};
type AccordionItemProps = {
    accordions?: string[];
    title?: string;
    index?: number;
    children?: React.ReactNode;
    parentSetting?: AccordionProps['setting'];
    parentStyle?: AccordionProps['styles'];
    childrenIcon?: string;
    handleDropDown?: (id: string) => void;
    parentUid: string;
} & BasePropsWrap;

declare const Accordion$2: React.FC<AccordionProps>;

declare const AccordionItem$1: React.FC<AccordionItemProps>;

declare const accordionSetting: {
    Accordion: _gem_sdk_core.ComponentSetting<AccordionProps>;
    AccordionItem: _gem_sdk_core.ComponentSetting<AccordionItemProps>;
};

type TextStyleProps = {
    textColor?: ColorValueType;
    parentTextColor?: StateProp<ColorValueType>;
    textShadowNotState?: ShadowProps;
    hasTextShadowNotState?: boolean;
    color?: StateProp<ColorValueType>;
    lineColor?: StateProp<ColorValueType>;
    typo?: TypographySettingV2;
    textAlign?: ObjectDevices<AlignProp>;
    lineClamp?: ObjectDevices<number>;
    hasLineClamp?: ObjectDevices<boolean>;
    hasTextShadow?: StateProp<boolean>;
    textShadow?: StateProp<ShadowProps>;
    transform?: TransformProp;
    spacing?: string;
    thickness?: string | number;
    underlineLink?: {
        hover: boolean;
        normal: boolean;
    };
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    /**
     * @deprecated this prop do not use anymore
     */
    hasBoxShadow?: StateProp<boolean>;
    /**
     * @deprecated this prop do not use anymore
     */
    boxShadow?: StateProp<ShadowProps>;
    align?: ObjectDevices<AlignProp>;
    shapeBorder?: ObjectDevices<Border>;
    shapeRounded?: ObjectDevices<CornerRadius>;
    shapeBoxShadow?: ObjectDevices<ShadowProps>;
    isForceValue?: boolean;
    lineThrough?: boolean;
    opacityPrice?: number;
    enableHoverEffect?: boolean;
};
type HTMLTag = 'p' | 'span' | 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'small' | 'mark' | 'kbd' | 'i';
type TextSettingProps = {
    text?: string | number;
    translateSetting?: string;
    htmlTag?: HTMLTag;
    opacityPrice?: number;
    options?: {
        useState?: boolean;
        uniqueId?: string | undefined;
        productID?: string | undefined;
        isCannotEditing?: boolean | undefined;
        disablePointerEvent?: boolean;
        customClass?: {
            wrapper?: string;
        };
    };
    tagWidth?: Record<string, string>;
    background?: ObjectDevices<BackgroundMedia>;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    excludeFlex?: boolean;
    isForceValue?: boolean;
};
type TextTranslateKeys = keyof (TextSettingProps & TextStyleProps);
type TextProps = BasePropsWrap<TextSettingProps, TextStyleProps> & Omit<React.ComponentPropsWithoutRef<'p'>, ''> & {
    disableEdit?: boolean;
    pageContext?: PageContext;
};

type ObjectFit$2 = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
type IImageStorageType = 'THEME' | 'FILE_CONTENT' | 'SHOPIFY_CDN';
type BaseImageData = {
    alt?: string;
    src?: string;
    width?: number;
    height?: number;
    base64?: string;
    backupFileKey?: string;
    backupFilePath?: string;
    storage?: IImageStorageType;
    metafieldDefinitionKey?: string;
};
type SharedProps = {
    aspectRatio?: ObjectDevices<string>;
    layout?: ObjectDevices<ObjectFit$2>;
    objectFit?: ObjectDevices<ObjectFit$2>;
    borderRadius?: ResponsiveStateProp<string>;
    image?: BaseImageData;
};
type MixedProps$1 = Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'children' | 'width' | 'height' | 'as' | 'src' | 'srcSet'>;
type ImgProps = SharedProps & MixedProps$1;
type ImageStyleProps$1 = {
    shape?: ObjectDevices<SizeSettingGlobal>;
    customAspectRadio?: ObjectDevices<Ratio>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<number | string>;
    align?: ObjectDevices<AlignProp>;
    opacity?: StateProp<number>;
    opacityColor?: StateProp<ColorValueType>;
    hasBoxShadowImg?: StateProp<boolean>;
    boxShadowImg?: StateProp<ShadowProps>;
    roundedImg?: StateProp<CornerRadius>;
    borderImg?: StateProp<Border>;
    borderRadius?: CornerRadius;
    wrapperBorder?: Border;
    hasActiveShadow?: boolean;
    shadow?: ShadowProps;
} & Pick<SharedProps, 'layout' | 'aspectRatio' | 'objectFit'>;
type ImageLink = {
    type?: string;
    link?: string;
    target?: string;
    noFollow?: boolean;
    isTranslate?: boolean;
};
type ImageSettingProps$1 = {
    imageStyle?: 'rectangle' | 'circle';
    priority?: boolean;
    quality?: number;
    vw?: ObjectDevices<number>;
    alt?: string;
    title?: string;
    isAdaptive?: boolean;
    imageLink?: ImageLink;
    hoverEffect?: string;
    image?: BaseImageData;
    isNotLazyload?: boolean;
    enableImageLink?: boolean;
    disableNoDataState?: boolean;
    srcSet?: ObjectDevices<BaseImageData>;
    qualityPercent?: ObjectDevices<number>;
    qualityType?: ObjectDevices<QualityType$3>;
};
type QualityType$3 = 'finest' | 'high' | 'medium' | 'custom';
type ImageTranslateKeys = keyof (ImageSettingProps$1 & ImageStyleProps$1);
type ImageProps = BasePropsWrap<ImageSettingProps$1, ImageStyleProps$1> & {
    className?: string;
    children?: React.ReactNode;
    onClick?: React.MouseEventHandler<any>;
    onLoad?: React.ReactEventHandler<any>;
} & {
    advanced?: any;
};
type ImageLiquidProps = ImageProps & {
    enableLazyLoadImage?: boolean;
    pageContext?: PageContext;
};

declare const Image$2: React.FC<ImageProps>;

declare const imageSetting: {
    Image: _gem_sdk_core.ComponentSetting<ImageProps>;
};

type MixedProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> | Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'type'>;
type ButtonSettingProps = {
    iconSvg?: string;
    loading?: boolean;
    disabled?: boolean;
    iconVisible?: boolean;
    innerBorder?: boolean;
    label?: React.ReactNode;
    disabledLoading?: boolean;
    shouldClearSpace?: boolean;
    iconAlign?: 'left' | 'right';
    htmlType?: React.ButtonHTMLAttributes<HTMLButtonElement>['type'] | 'link';
    enableBtnLink?: boolean;
    btnLink?: {
        type?: string;
        link?: string;
        target?: string;
        noFollow?: boolean;
    };
    options?: {
        isCannotEditing?: boolean | undefined;
    };
    enableHoverEffect?: boolean;
    enableActiveEffect?: boolean;
};
type ButtonStyleProps = {
    size?: ObjectDevices<string>;
    type?: 'primary' | 'secondary';
    align?: ObjectDevices<AlignProp>;
    fullWidth?: ObjectDevices<boolean>;
    roundedBtn?: StateProp<CornerRadius>;
    textColor?: StateProp<ColorValueType>;
    backgroundColor?: StateProp<ColorValueType>;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    iconDimension?: ObjectDevices<number | string>;
    width?: ObjectDevices<string | number | undefined>;
    height?: ObjectDevices<string | number | undefined>;
    roundedBtnV2?: StateProp<CornerRadius>;
    animation?: StateProp<'none' | 'pulse' | 'grow' | 'bounce'>;
    backgroundColorV2?: StateProp<ColorValueType>;
    backgroundImage?: StateProp<BackgroundImageValue>;
    enableTextStyle?: boolean;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    transform?: string;
    iconSizeAuto?: boolean;
    textOverFlow?: boolean;
    preloadBgImage?: boolean;
    btnSpacing?: SizeSetting;
    typo?: TypographySettingV2;
    borderBtn?: StateProp<Border>;
    iconSpacing?: ObjectDevices<string>;
    textAlign?: ObjectDevices<AlignProp>;
    hasBoxShadowBtn?: StateProp<boolean>;
    boxShadowBtn?: StateProp<ShadowProps>;
    borderBtnV2?: StateProp<Border>;
    boxShadowBtnV2?: StateProp<ShadowProps>;
};
type ButtonTranslateKeys = keyof (ButtonSettingProps & ButtonStyleProps);
type ButtonProps = MixedProps & BasePropsWrap<ButtonSettingProps, ButtonStyleProps> & {
    dataId?: string;
    customAttrs?: any;
    wrapClassName?: string;
    nodePrice?: JSX.Element | string;
};
type ButtonLiquidProps = ButtonProps & {
    translateSetting?: string;
    isForceValue?: boolean;
    isUseTranslatedValue?: boolean;
    pageContext?: PageContext;
};

type PickMethod = 'latest' | 'manually';
type ArticleSortedByOrderType = 'PUBLISHED_AT' | 'PUBLISHED_AT_REVERSE' | 'UPDATED_AT' | 'UPDATED_AT_REVERSE' | 'TITLE' | 'TITLE_REVERSE';
type ArticleListSettingProps = {
    articleSetting?: {
        articleIds?: string[];
        numOfSelectedArticles?: number;
        blogId?: string;
        blogHandle?: string;
        articlePickType?: PickMethod;
        articleHandles?: string[];
        articleBlogTitles?: string[];
    };
    background?: ObjectDevices<Background>;
    numberOfArticle?: number;
    slideToShow?: ObjectDevices<number | 'auto'>;
    col?: number;
    loop?: ObjectDevices<boolean>;
    scrollMode?: ObjectDevices<'snap' | 'free' | 'free-snap'>;
    articleOrderBy?: ArticleSortedByOrderType;
    dragToScroll?: boolean;
};
type ArticleListStyleProps = {
    layout?: 'grid' | 'slider';
    horizontalGutter?: ObjectDevices<string>;
    verticalGutter?: ObjectDevices<string>;
    fullWidth?: ObjectDevices<boolean>;
    adaptiveHeight?: ObjectDevices<boolean>;
    spacing?: ObjectDevices<number>;
    width?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
    borderRadius?: CornerRadius;
    wrapperBorder?: Border;
    hasActiveShadow?: boolean;
    shadow?: ShadowProps;
    padding?: ObjectDevices<SizeSettingGlobal>;
};
type ArticleListProps = BasePropsWrap<ArticleListSettingProps, ArticleListStyleProps> & {
    style?: React.CSSProperties;
    className?: string;
    children: React.ReactNode;
    pageContext?: PageContext;
};
type ArticleTitleSettingProps = TextSettingProps & {
    linkArticle?: string;
    customURL?: {
        link?: string;
        target?: string;
        type?: any;
    };
    enableLink?: boolean;
    openNewTab?: boolean;
};
type ArticleTitleProps = BasePropsWrap<ArticleTitleSettingProps, TextStyleProps>;
type ArticleExcerptProps = BasePropsWrap<TextSettingProps & {
    linkArticle?: boolean;
}, TextStyleProps>;
type ArticleContentProps = BasePropsWrap<TextSettingProps, TextStyleProps>;
type ArticleImageSettingProps = ImageProps['setting'] & {
    linkArticle?: string;
    customURL?: {
        link?: string;
        target?: string;
        type?: any;
    };
    enableLink?: boolean;
    openNewTab?: boolean;
};
type ArticleImageProps = BasePropsWrap<ArticleImageSettingProps, Pick<ImageStyleProps$1, 'opacity' | 'opacityColor' | 'shape' | 'objectFit' | 'align' | 'borderRadius' | 'wrapperBorder' | 'shadow'> & {
    qualityPercent?: ObjectDevices<number>;
    qualityType?: ObjectDevices<QualityType$3>;
}> & {
    className?: string;
    style?: React.CSSProperties;
};
type ArticleAuthorProps = BasePropsWrap<ArticleAuthorSettingProps, TextStyleProps>;
type ArticleAuthorSettingProps = {
    linkArticle?: boolean;
    prefix: string;
} & TextSettingProps;
type ArticleTagProps = BasePropsWrap<TextSettingProps, TextStyleProps>;
type ArticleCategorySettingProps = TextSettingProps & {
    linkArticle?: boolean;
};
type ArticleCategoryProps = BasePropsWrap<ArticleCategorySettingProps, TextStyleProps>;
type ArticleDateProps = BasePropsWrap<TextSettingProps & {
    linkArticle?: boolean;
    dateFormat?: string;
}, TextStyleProps>;
type ArticleReadMoreSidebarSettingProps = {
    setting: Pick<OriginalArticleReadMoreSettingProps, 'readMoreType' | 'label'> & Pick<TextSettingProps, 'htmlTag' | 'text' | 'background'> & Pick<ButtonSettingProps, 'iconVisible' | 'iconSvg' | 'iconAlign' | 'htmlType' | 'disabled' | 'shouldClearSpace' | 'enableHoverEffect'>;
    styles: Pick<ArticleReadMoreStyleProps, 'iconSpacing' | 'borderBtn' | 'borderBtnV2' | 'backgroundColorV2' | 'backgroundColor' | 'backgroundImage' | 'textColorBtnState' | 'roundedBtn' | 'roundedBtnV2' | 'boxShadowBtn' | 'hasBoxShadowBtn' | 'alignBtn' | 'enableTextStyle' | 'typoBtn' | 'transform' | 'btnSpacing' | 'fullWidth' | 'width' | 'iconSizeAuto' | 'size' | 'iconDimension' | 'globalSizeBtn' | 'textColorTextState' | 'typoText' | 'alignText' | 'hasLineClamp' | 'lineClamp' | 'globalSizeText' | 'spacing'> & {
        enableHoverEffectText?: boolean;
    } & Pick<ButtonStyleProps, 'textColor'>;
};
type OriginalArticleReadMoreSettingProps = {
    readMoreType: 'text' | 'button' | 'rounded' | 'outline';
    label: string | React.ReactNode;
};
type ArticleReadMoreSettingProps = TextSettingProps & ButtonSettingProps & OriginalArticleReadMoreSettingProps;
type ArticleReadMoreStyleProps = TextStyleProps & ButtonStyleProps & {
    textColorBtnState?: StateProp<ColorValueType>;
    textColorTextState?: StateProp<ColorValueType>;
    typoBtn?: TypographySettingV2;
    typoText?: TypographySettingV2;
    enableTextStyle?: boolean;
    enableHoverEffectText?: boolean;
    globalSizeBtn?: ObjectDevices<SizeSettingGlobal>;
    globalSizeText?: ObjectDevices<SizeSettingGlobal>;
    alignBtn?: ObjectDevices<AlignProp>;
    alignText?: ObjectDevices<AlignProp>;
    background?: ObjectDevices<BackgroundMedia>;
    iconSpacing?: ObjectDevices<string>;
};
type ArticleReadMoreTranslateKeys = Extract<keyof ArticleReadMoreSettingProps, 'label'>;
type ArticlePaginationTranslateKeys = 'previousText' | 'nextText';
type ArticleReadMoreProps = BasePropsWrap<ArticleReadMoreSettingProps, ArticleReadMoreStyleProps> & {
    className?: string;
    pageContext?: PageContext;
};

declare const ArticleList$1: React.FC<ArticleListProps>;

declare const ArticleTitle$1: React.FC<ArticleTitleProps>;

declare const ArticleExcerpt$1: React.FC<ArticleExcerptProps>;

declare const ArticleContent$1: React.FC<ArticleContentProps>;

declare const ArticleImage$1: React.FC<ArticleImageProps>;

type ColSettingProps = {
    allowSameHeight?: boolean;
    sameHeightSubgridContainer?: boolean;
};
type ColStyleProps = {
    order?: ObjectDevices<number>;
    gap?: ObjectDevices<string>;
    alignItem?: ObjectDevices<Property.AlignItems>;
    justifyContent?: ObjectDevices<Property.JustifyContent>;
    display?: ObjectDevices<Property.Display>;
    fullWidth?: boolean;
};
type ColProps = BasePropsWrap<ColSettingProps, ColStyleProps> & React.ComponentPropsWithoutRef<'div'> & {
    justifyContent?: ObjectDevices<Property.JustifyContent>;
    order?: ObjectDevices<number>;
    className?: string;
    children?: any;
    layout?: ObjectDevices<ObjectLayoutValue>;
    parentTag?: string;
    rawChildren?: any[];
    hiddenEmptyCol?: boolean;
} & {
    advanced?: any;
};
type RowSettingProps = {
    responsive?: ObjectDevices<string>;
    layout?: ObjectDevices<ObjectLayoutValue>;
    verticalAlign?: ObjectDevices<'start' | 'end' | 'center' | 'space-between'>;
    horizontalAlign?: ObjectDevices<'start' | 'end' | 'center' | 'space-between'>;
    order?: ObjectDevices<number>;
    inlineAlignment?: 'start' | 'end' | 'center';
    blockAlignment?: 'start' | 'end' | 'center';
    allowSameHeight?: boolean;
    sameHeightSubgridContainer?: boolean;
    isSection?: boolean;
    lazy?: boolean;
    priority?: boolean;
    as?: 'div' | 'section';
};
type RowStyleProps = {
    enablePagePadding?: ObjectDevices<boolean>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    height?: ObjectDevices<'auto' | '100%'>;
    preloadBgImage?: boolean;
    columnGap?: ObjectDevices<string>;
    rowGap?: string;
    border?: ObjectDevices<StateProp<Border>>;
    rounded?: ObjectDevices<StateProp<CornerRadius>>;
    padding?: ObjectDevices<SizeSettingGlobal>;
    verticalGutter?: ObjectDevices<string>;
    verticalGutterMobile?: ObjectDevices<string>;
    background?: ObjectDevices<BackgroundMedia>;
    boxShadow?: ObjectDevices<StateProp<ShadowProps>>;
};
type RowTranslateKeys = keyof RowStyleProps;
type RowProps = BasePropsWrap<RowSettingProps, RowStyleProps> & React.ComponentPropsWithoutRef<'div'> & {
    maxWidthWithEmptyChildren?: string | number;
    isNotFullWidth?: boolean;
    rawChildren?: any[];
    hiddenEmptyCol?: boolean;
    parentStyle?: React.CSSProperties;
    pageContext?: PageContext;
};
type RootProps$2 = {
    children?: React.ReactNode;
};

type CollectionToolbarSettingProps = {
    sortingTextDisplay?: string;
    displayQuantity?: boolean;
    quantityTextDisplay?: string;
    typoSorting?: TypographySettingV2;
    typoQuantity?: TypographySettingV2;
    width?: ObjectDevices<string | number>;
    height?: ObjectDevices<string | number>;
    align?: ObjectDevices<AlignProp>;
    /**
     * @deprecated please use `typoSorting` instead
     */
    typographySorting?: TypographySetting;
    /**
     * @deprecated please use color inside `typoSorting` instead
     */
    colorSorting?: ColorValueType;
    /**
     * @deprecated please use `typoQuantity` instead
     */
    typographyQuantity?: TypographySetting;
    /**
     * @deprecated please use color inside `typoQuantity` instead
     */
    colorQuantity?: ColorValueType;
};
type CollectionToolbarTranslateKeys = Extract<keyof CollectionToolbarSettingProps, 'sortingTextDisplay' | 'quantityTextDisplay'>;
type CollectionToolbarProps = BaseProps<CollectionToolbarSettingProps> & {
    pageContext?: PageContext;
};
type CollectionTitleSettingProps = {
    htmlTag?: HTMLTag;
    textAlign?: ObjectDevices<AlignProp>;
    /**
     * @deprecated please use color inside `typo` instead
     */
    textColor?: ColorValueType;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use transform inside `typo` instead
     */
    transform?: TransformProp;
};
type CollectionTitleProps = BaseProps<CollectionTitleSettingProps>;
type CollectionPaginatorSettingProps = {
    pageQuantity?: string;
    layout?: string;
    buttonShape?: string;
    buttonSizeNumber?: number;
    itemSpacing?: number | string;
    previousText?: string;
    nextText?: string;
    /**
     * @deprecated please use `typo` instead
     */
    typographyPaginator?: TypographySetting;
    typo?: TypographySettingV2;
    normalColor?: ColorValueType;
    activeColor?: ColorValueType;
    align?: ObjectDevices<AlignProp>;
    numberOfProducts?: number;
};
type CollectionPaginatorTranslateKeys = Extract<keyof CollectionPaginatorSettingProps, 'previousText' | 'nextText'>;
type CollectionPaginatorProps = BasePropsWrap<CollectionPaginatorSettingProps> & {
    pageContext?: PageContext;
};
type CollectionDescriptionSettingProps = {
    textAlign?: ObjectDevices<AlignProp>;
    /**
     * @deprecated please use color inside `typo` instead
     */
    textColor?: ColorValueType;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use transform inside `typo` instead
     */
    color?: ColorValueType;
    transform?: TransformProp;
    showMoreColor?: ColorValueType;
    hasLineClamp?: ObjectDevices<boolean>;
    lineClamp?: ObjectDevices<number>;
    viewMoreText?: string;
    viewLessText?: string;
    enableViewMoreIcon?: boolean;
    htmlTag?: 'plaintext' | 'html';
};
type CollectionDescriptionTranslateKeys = Extract<keyof CollectionDescriptionSettingProps, 'viewLessText' | 'viewMoreText'>;
type CollectionDescriptionProps = BaseProps<CollectionDescriptionSettingProps> & {
    pageContext?: PageContext;
};
type CollectionBannerOriginalSettingProps = {
    link?: {
        link?: string;
        target?: string;
    };
    hoverEffect?: 'none' | 'zoom';
    hoverScale?: number;
    hoverDuration?: string;
    overlayColor?: StateProp<ColorValueType>;
    overlayOpacity?: StateProp<string>;
    fixedMode?: boolean;
    height?: ObjectDevices<string>;
    contentPosition?: string;
    container?: boolean;
};
type CollectionBannerSettingProps = CollectionBannerOriginalSettingProps & Pick<RowSettingProps, 'layout' | 'horizontalAlign' | 'verticalAlign'> & Pick<RowStyleProps, 'background' | 'fullWidth' | 'width' | 'verticalGutter'>;
type CollectionBannerProps = BasePropsWrap<CollectionBannerSettingProps> & {
    children?: React.ReactNode;
};

declare const ArticlePagination$2: React.FC<CollectionPaginatorProps>;

declare const ArticleAuthor$1: React.FC<ArticleAuthorProps>;

declare const ArticleTag$1: React.FC<ArticleTagProps>;

declare const ArticleCategory$1: React.FC<ArticleCategoryProps>;

declare const ArticleDate$1: React.FC<ArticleDateProps>;

declare const ArticleReadMore$2: React.FC<ArticleReadMoreProps>;

declare const articleListSetting: {
    ArticleList: _gem_sdk_core.ComponentSetting<ArticleListProps>;
    ArticleTitle: _gem_sdk_core.ComponentSetting<ArticleTitleProps>;
    ArticleExcerpt: _gem_sdk_core.ComponentSetting<ArticleExcerptProps>;
    ArticleContent: _gem_sdk_core.ComponentSetting<ArticleContentProps>;
    ArticleImage: _gem_sdk_core.ComponentSetting<ArticleImageProps>;
    ArticlePagination: _gem_sdk_core.ComponentSetting<CollectionPaginatorProps>;
    ArticleAuthor: _gem_sdk_core.ComponentSetting<ArticleAuthorProps>;
    ArticleTag: _gem_sdk_core.ComponentSetting<ArticleTagProps>;
    ArticleCategory: _gem_sdk_core.ComponentSetting<ArticleCategoryProps>;
    ArticleDate: _gem_sdk_core.ComponentSetting<ArticleDateProps>;
    ArticleReadMore: _gem_sdk_core.ComponentSetting<ArticleReadMoreSidebarSettingProps>;
};

type ObjectFit$1 = 'cover' | 'contain';
type HeroBannerSettingProps = {
    link?: {
        link?: string;
        target?: string;
        type?: string;
    };
    preload?: boolean;
    order?: ObjectDevices<number>;
    enableParallax?: boolean;
    speedParallax?: number;
    verticalAlign?: ObjectDevices<'start' | 'end' | 'center' | 'space-between'>;
    alignBanner?: ObjectDevices<'left' | 'center' | 'right'>;
    alt?: string;
    title?: string;
    aspectRatio?: ObjectDevices<string>;
    ratioOptions?: ObjectDevices<Ratio>;
    enableLink?: boolean;
    contentBanner?: string;
    isYoutubeVideoMigrated?: boolean;
} & Pick<RowSettingProps, 'layout' | 'horizontalAlign'>;
type HeroBannerStyleProps = {
    height?: ObjectDevices<string>;
    overlayEnable?: boolean;
    overlayColor?: StateProp<ColorValueType>;
    overlayOpacity?: StateProp<string | number>;
    contentPosition1Col?: ObjectDevices<'center' | 'top' | 'bottom' | 'space-between'>;
    contentPosition2Col?: ObjectDevices<'center' | 'top' | 'bottom' | 'space-between'>;
    container?: boolean;
    hoverEffect?: boolean;
    hoverEffectScale?: number | string;
    hoverEffectDuration?: number;
    wrapperWidth?: ObjectDevices<string>;
    contentWidth?: ObjectDevices<string>;
    cornerBg?: CornerRadius;
    borderBg?: Border;
    hasActiveShadow?: boolean;
    shadowBg?: ShadowProps;
    sizeSetting?: ObjectDevices<SizeSettingGlobal>;
    order?: ObjectDevices<number>;
    contentPadding?: ObjectDevices<PaddingType$2>;
    videoObjectFit?: ObjectDevices<ObjectFit$1>;
} & Pick<RowStyleProps, 'verticalGutter' | 'background'>;
type HeroBannerTranslateKeys = keyof (HeroBannerSettingProps & HeroBannerStyleProps);
type HeroBannerProps = BasePropsWrap<HeroBannerSettingProps, HeroBannerStyleProps> & {
    children?: React.ReactNode;
    rawChildren?: any[];
    advanced?: any;
    pageContext?: PageContext;
    enableLazyLoadImage?: boolean;
};
type DataVideoType = {
    data: Background;
    device: NameDevices;
};

declare const HeroBanner$2: React.FC<HeroBannerProps>;

declare const bannerSetting: {
    HeroBanner: _gem_sdk_core.ComponentSetting<HeroBannerProps>;
};

type BreadcrumbSettingProps = {
    iconWidth?: ObjectDevices<number>;
    hideCurrentPage?: ObjectDevices<boolean>;
    align?: ObjectDevices<AlignProp>;
    labelColor?: StateProp<ColorValueType>;
    fontWeight?: StateProp<string>;
    background?: ObjectDevices<Background>;
    spacing?: ObjectDevices<string>;
    color?: ColorValueType;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    iconSvg?: string;
    enableHoverEffect?: boolean;
    enableActiveEffect?: boolean;
};
type BreadcrumbStyleProps = {
    typo?: TypographySettingV2;
};
type BreadcrumbProps = BasePropsWrap<BreadcrumbSettingProps, BreadcrumbStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};

declare const Breadcrumb$1: React.FC<BreadcrumbProps>;

declare const breadcrumbSetting: {
    Breadcrumb: _gem_sdk_core.ComponentSetting<BreadcrumbProps>;
};

declare const Button$3: React.FC<ButtonProps>;

declare const buttonSetting: {
    Button: _gem_sdk_core.ComponentSetting<ButtonProps>;
};

declare const CAROUSEL_ANIMATION$1: {
    readonly EASE_IN: {
        readonly value: "ease-in";
        readonly formula: (t: number) => number;
    };
    readonly EASE_OUT: {
        readonly value: "ease-out";
        readonly formula: (t: number) => number;
    };
    readonly EASE_IN_OUT: {
        readonly value: "ease-in-out";
        readonly formula: (t: number) => number;
    };
    readonly DEFAULT: {
        readonly value: "default";
        readonly formula: (t: number) => number;
    };
};
type CarouselAnimationValue$1 = (typeof CAROUSEL_ANIMATION$1)[keyof typeof CAROUSEL_ANIMATION$1]['value'];

type NavigationStyle$1 = 'none' | 'inside' | 'outside';
type PaddingType$1 = {
    type?: 'small' | 'medium' | 'large' | 'custom';
    top?: string;
    left?: string;
    bottom?: string;
    right?: string;
    linked?: boolean;
};
type DotStyle$1 = 'none' | 'inside' | 'outside';
type InteractionChangeSlide$1 = {
    key: string;
    data: number;
    isRollback: boolean;
    index?: number;
    element: HTMLElement;
};
type CarouselRef$1 = {
    nextSlideInteraction: (params: InteractionChangeSlide$1) => void;
    previousSlideInteraction: (params: InteractionChangeSlide$1) => void;
    moveToSlideInteraction: (params: InteractionChangeSlide$1) => void;
    getSwiper: () => Swiper | null;
};
type CarouselSettingProps$1 = {
    slidesToShow?: ObjectDevices<number | 'auto'>;
    slidesToScroll?: ObjectDevices<number>;
    childItem?: string[];
    vertical?: ObjectDevices<boolean>;
    dot?: ObjectDevices<boolean>;
    speed?: number;
    arrow?: ObjectDevices<boolean>;
    controlOverContent?: ObjectDevices<boolean>;
    autoplaySpeed?: number;
    dotColor?: ObjectDevices<ColorValueType>;
    dotActiveColor?: ObjectDevices<ColorValueType>;
    dotStyle?: ObjectDevices<DotStyle$1>;
    dotSize?: ObjectDevices<number>;
    dotGapToCarousel?: ObjectDevices<number>;
    navigationStyle?: ObjectDevices<NavigationStyle$1>;
    navigationEnable?: ObjectDevices<boolean>;
    arrowCustomColor?: ColorValueType;
    arrowCustom?: string;
    arrowIconSize?: ObjectDevices<number>;
    arrowButtonSize?: ObjectDevices<{
        shapeLinked?: boolean;
        shapeValue?: string;
        width?: string;
        height?: string;
        padding?: PaddingType$1;
    }>;
    rtl?: boolean;
    arrowBackgroundColor?: string;
    arrowBorder?: ObjectDevices<Border>;
    arrowShadow?: ObjectDevices<ShadowProps>;
    roundedArrow?: ObjectDevices<CornerRadius>;
    arrowGapToEachSide?: string;
    showWhenHover?: boolean;
    defaultCurrentSlider?: number;
    background?: ObjectDevices<BackgroundMedia>;
    label?: boolean;
    sneakPeak?: ObjectDevices<boolean>;
    sneakPeakOffsetForward?: ObjectDevices<number>;
    sneakPeakOffsetCenter?: ObjectDevices<number>;
    sneakPeakType?: ObjectDevices<'center' | 'forward'>;
    itemNumber?: ObjectDevices<number | 'auto'>;
    runPreview?: boolean;
    autoplayTimeout?: number;
    pauseOnHover?: boolean;
    autoplay?: boolean;
    enableDrag?: ObjectDevices<boolean>;
    loop?: ObjectDevices<boolean>;
    animationMode?: CarouselAnimationValue$1;
    layout?: 'vertical' | 'hozirontal';
    enableAction?: ObjectDevices<boolean>;
    initialSlide?: number;
};
type CarouselStyleProps$1 = {
    spacing?: ObjectDevices<number>;
    roundedContent?: CornerRadius;
    borderContent?: Border;
    hasActiveShadow?: boolean;
    carouselShadow?: ShadowProps;
    align?: ObjectDevices<AlignProp | Property.AlignItems>;
    sizeSetting?: ObjectDevices<SizeSettingGlobal>;
    playSpeed?: number;
    itemPadding?: ObjectDevices<SizeSettingGlobal>;
    backgroundColor?: ObjectDevices<string>;
    backgroundImage?: ObjectDevices<BackgroundImageValue>;
};
type CarouselProps$1 = BasePropsWrap<CarouselSettingProps$1, CarouselStyleProps$1> & {
    children?: React.ReactNode;
    moveToIdx?: number;
    isHiddenArrowWhenDisabled?: boolean;
    hiddenDotWhenOnlyOne?: boolean;
    disableMarginAuto?: boolean;
    onLoaded?: (status: boolean) => void;
    onChangeActive?: (index: number) => void;
    onUpdated?: (slider: KeenSliderInstance) => void;
    onCreated?: (slider: KeenSliderInstance) => void;
    onClickArrow?: () => void;
    onHandleChangeSlideByInteraction?: (index: number) => void;
    onSwiperReady?: (swiper: Swiper) => void;
    elmRef?: React.Ref<HTMLDivElement>;
    rootClass?: string;
    parentClass?: string;
    rootAttrs?: Record<string, string | boolean | number>;
    slidesClass?: string;
    fullHeight?: boolean;
    isDisableResetSlide?: boolean;
    isProductList?: boolean;
    thumbsSwiper?: string;
    productBadgeLiquid?: string;
} & {
    rootId?: string;
    rootClass?: string;
    wrapperClass?: string;
    rootStyles?: React.CSSProperties;
    rawChildren?: any[];
    advanced?: any;
    disableMarginAuto?: boolean;
    slidesClass?: string;
    conditionAppendJs?: string;
    isEnableCheckHasScrollableContent?: boolean;
};
type CarouselItemProps$1 = {
    parentStyle?: CarouselProps$1['styles'];
    customStyle?: React.CSSProperties;
    parentSettings?: CarouselProps$1['setting'];
    background?: Partial<Record<NameDevices, Background>> | undefined;
    index?: number;
    contentType?: 'normalItem' | 'productImage';
    onClickItem?: React.MouseEventHandler<any>;
    dispatchEventSelectSlide?: (index: number) => void;
    parentId?: string;
    parentUid?: string;
    indexKey?: string;
} & BasePropsWrap & React.ComponentPropsWithoutRef<'div'>;

declare const Carousel$3: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<CarouselSettingProps$1, CarouselStyleProps$1, Record<string, any>> & {
    builderAttrs?: Record<string, any>;
    style?: React.CSSProperties;
} & {
    children?: React.ReactNode;
    moveToIdx?: number;
    isHiddenArrowWhenDisabled?: boolean;
    hiddenDotWhenOnlyOne?: boolean;
    disableMarginAuto?: boolean;
    onLoaded?: (status: boolean) => void;
    onChangeActive?: (index: number) => void;
    onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
    onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
    onClickArrow?: () => void;
    onHandleChangeSlideByInteraction?: (index: number) => void;
    onSwiperReady?: (swiper: Swiper) => void;
    elmRef?: React.Ref<HTMLDivElement>;
    rootClass?: string;
    parentClass?: string;
    rootAttrs?: Record<string, string | boolean | number>;
    slidesClass?: string;
    fullHeight?: boolean;
    isDisableResetSlide?: boolean;
    isProductList?: boolean;
    thumbsSwiper?: string;
    productBadgeLiquid?: string;
} & {
    rootId?: string;
    rootClass?: string;
    wrapperClass?: string;
    rootStyles?: React.CSSProperties;
    rawChildren?: any[];
    advanced?: any;
    disableMarginAuto?: boolean;
    slidesClass?: string;
    conditionAppendJs?: string;
    isEnableCheckHasScrollableContent?: boolean;
} & React.RefAttributes<CarouselRef$1>>;

declare const CarouselItem$3: React.FC<CarouselItemProps$1>;

declare const carouselSettingV3: {
    CarouselV3: _gem_sdk_core.ComponentSetting<CarouselProps$1>;
    CarouselItemV3: _gem_sdk_core.ComponentSetting<CarouselItemProps$1>;
};

declare const CAROUSEL_ANIMATION: {
    readonly EASE_IN: {
        readonly value: "ease-in";
        readonly formula: (t: number) => number;
    };
    readonly EASE_OUT: {
        readonly value: "ease-out";
        readonly formula: (t: number) => number;
    };
    readonly EASE_IN_OUT: {
        readonly value: "ease-in-out";
        readonly formula: (t: number) => number;
    };
    readonly DEFAULT: {
        readonly value: "default";
        readonly formula: (t: number) => number;
    };
};
type CarouselAnimationValue = (typeof CAROUSEL_ANIMATION)[keyof typeof CAROUSEL_ANIMATION]['value'];

type NavigationStyle = 'none' | 'inside' | 'outside';
type PaddingType = {
    type?: 'small' | 'medium' | 'large' | 'custom';
    top?: string;
    left?: string;
    bottom?: string;
    right?: string;
    linked?: boolean;
};
type DotStyle = 'none' | 'inside' | 'outside';
type InteractionChangeSlide = {
    key: string;
    data: number;
    isRollback: boolean;
    index?: number;
    element: HTMLElement;
};
type CarouselRef = {
    nextSlideInteraction: (params: InteractionChangeSlide) => void;
    previousSlideInteraction: (params: InteractionChangeSlide) => void;
    moveToSlideInteraction: (params: InteractionChangeSlide) => void;
};
type CarouselSettingProps = {
    slidesToShow?: ObjectDevices<number | 'auto'>;
    slidesToScroll?: ObjectDevices<number>;
    childItem?: string[];
    vertical?: ObjectDevices<boolean>;
    dot?: ObjectDevices<boolean>;
    speed?: number;
    arrow?: ObjectDevices<boolean>;
    controlOverContent?: ObjectDevices<boolean>;
    autoplaySpeed?: number;
    dotColor?: ObjectDevices<ColorValueType>;
    dotActiveColor?: ObjectDevices<ColorValueType>;
    dotStyle?: ObjectDevices<DotStyle>;
    dotSize?: ObjectDevices<number>;
    dotGapToCarousel?: ObjectDevices<number>;
    navigationStyle?: ObjectDevices<NavigationStyle>;
    navigationEnable?: ObjectDevices<boolean>;
    arrowCustomColor?: ColorValueType;
    arrowCustom?: string;
    arrowIconSize?: ObjectDevices<number>;
    arrowButtonSize?: ObjectDevices<{
        shapeLinked?: boolean;
        shapeValue?: string;
        width?: string;
        height?: string;
        padding?: PaddingType;
    }>;
    rtl?: boolean;
    arrowBackgroundColor?: string;
    arrowBorder?: ObjectDevices<Border>;
    arrowShadow?: ObjectDevices<ShadowProps>;
    roundedArrow?: ObjectDevices<CornerRadius>;
    arrowGapToEachSide?: string;
    showWhenHover?: boolean;
    defaultCurrentSlider?: number;
    background?: ObjectDevices<BackgroundMedia>;
    label?: boolean;
    sneakPeak?: ObjectDevices<boolean>;
    sneakPeakOffsetForward?: ObjectDevices<number>;
    sneakPeakOffsetCenter?: ObjectDevices<number>;
    sneakPeakType?: ObjectDevices<'center' | 'forward'>;
    itemNumber?: ObjectDevices<number | 'auto'>;
    runPreview?: boolean;
    autoplayTimeout?: number;
    pauseOnHover?: boolean;
    autoplay?: boolean;
    enableDrag?: ObjectDevices<boolean>;
    loop?: ObjectDevices<boolean>;
    animationMode?: CarouselAnimationValue;
    layout?: 'vertical' | 'hozirontal';
    enableAction?: ObjectDevices<boolean>;
};
type CarouselStyleProps = {
    spacing?: ObjectDevices<number>;
    roundedContent?: CornerRadius;
    borderContent?: Border;
    hasActiveShadow?: boolean;
    carouselShadow?: ShadowProps;
    align?: ObjectDevices<AlignProp | Property.AlignItems>;
    sizeSetting?: ObjectDevices<SizeSettingGlobal>;
    playSpeed?: number;
    itemPadding?: ObjectDevices<SizeSettingGlobal>;
    backgroundColor?: ObjectDevices<string>;
    backgroundImage?: ObjectDevices<BackgroundImageValue>;
};
type CarouselProps = BasePropsWrap<CarouselSettingProps, CarouselStyleProps> & {
    children?: React.ReactNode;
    moveToIdx?: number;
    isHiddenArrowWhenDisabled?: boolean;
    hiddenDotWhenOnlyOne?: boolean;
    disableMarginAuto?: boolean;
    onLoaded?: (status: boolean) => void;
    onChangeActive?: (index: number) => void;
    onUpdated?: (slider: KeenSliderInstance) => void;
    onCreated?: (slider: KeenSliderInstance) => void;
    onClickArrow?: () => void;
    onHandleChangeSlideByInteraction?: (index: number) => void;
    elmRef?: React.Ref<HTMLDivElement>;
    rootClass?: string;
    parentClass?: string;
    rootAttrs?: Record<string, string | boolean | number>;
    slidesClass?: string;
    fullHeight?: boolean;
} & {
    rootId?: string;
    rootClass?: string;
    wrapperClass?: string;
    rootStyles?: React.CSSProperties;
    rawChildren?: any[];
    advanced?: any;
    disableMarginAuto?: boolean;
    slidesClass?: string;
    conditionAppendJs?: string;
};
type CarouselItemProps = {
    parentStyle?: CarouselProps['styles'];
    customStyle?: React.CSSProperties;
    parentSettings?: CarouselProps['setting'];
    background?: Partial<Record<NameDevices, Background>> | undefined;
    index?: number;
    contentType?: 'normalItem' | 'productImage';
    onClickItem?: React.MouseEventHandler<any>;
    dispatchEventSelectSlide?: (index: number) => void;
    parentId?: string;
    parentUid?: string;
} & BasePropsWrap & React.ComponentPropsWithoutRef<'div'>;

declare const Carousel$2: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<CarouselSettingProps, CarouselStyleProps, Record<string, any>> & {
    builderAttrs?: Record<string, any>;
    style?: React.CSSProperties;
} & {
    children?: React.ReactNode;
    moveToIdx?: number;
    isHiddenArrowWhenDisabled?: boolean;
    hiddenDotWhenOnlyOne?: boolean;
    disableMarginAuto?: boolean;
    onLoaded?: (status: boolean) => void;
    onChangeActive?: (index: number) => void;
    onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
    onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
    onClickArrow?: () => void;
    onHandleChangeSlideByInteraction?: (index: number) => void;
    elmRef?: React.Ref<HTMLDivElement>;
    rootClass?: string;
    parentClass?: string;
    rootAttrs?: Record<string, string | boolean | number>;
    slidesClass?: string;
    fullHeight?: boolean;
} & {
    rootId?: string;
    rootClass?: string;
    wrapperClass?: string;
    rootStyles?: React.CSSProperties;
    rawChildren?: any[];
    advanced?: any;
    disableMarginAuto?: boolean;
    slidesClass?: string;
    conditionAppendJs?: string;
} & React.RefAttributes<CarouselRef>>;

declare const CarouselItem$2: React.FC<CarouselItemProps>;

declare const carouselSetting: {
    Carousel: _gem_sdk_core.ComponentSetting<CarouselProps>;
    CarouselItem: _gem_sdk_core.ComponentSetting<CarouselItemProps>;
};

type ShopPayButtonSettingProps = {
    kind?: 'buy-now' | 'cart-buy';
    openMode?: 'new-page' | 'popup';
};
type ShopPayButtonStyleProps = {
    align?: ObjectDevices<AlignProp>;
    type?: 'dynamic' | 'express';
    color?: 'black' | 'white' | 'purple';
};
type ShopPayButtonProps = BasePropsWrap<ShopPayButtonSettingProps, ShopPayButtonStyleProps> & {
    className?: string;
    advanced?: any;
};
type ShopPayButtonSidebarSettingProps = {
    setting: Pick<ShopPayButtonSettingProps, 'openMode'>;
    styles: Pick<ShopPayButtonStyleProps, 'type' | 'color' | 'align'>;
};

type CartSettingProps = {
    svgIcon?: string;
    iconOnly?: boolean;
    label?: string;
    enableHoverEffect?: boolean;
};
type CartStyleProps = {
    iconColor?: StateProp<ColorValueType>;
};
type CartSidebarSettingProps = {
    setting: Pick<CartSettingProps, 'svgIcon' | 'iconOnly' | 'label' | 'enableHoverEffect'>;
    styles: Pick<CartStyleProps, 'iconColor'>;
};
type CartProps = BasePropsWrap<CartSettingProps, CartStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type CartLineImageSettingProps = {
    hoverEffect?: 'zoom' | 'blur' | 'none' | 'rotate';
};
type CartLineImageStyleProps = Pick<ImageStyleProps$1, 'layout' | 'aspectRatio' | 'roundedImg' | 'customAspectRadio' | 'opacity'>;
type CartLineImageSidebarSettingProps = {
    styles: Pick<CartLineImageStyleProps, 'aspectRatio' | 'customAspectRadio' | 'layout' | 'opacity' | 'roundedImg'>;
};
type CartLineImageProps = BaseProps<CartLineImageSettingProps, CartLineImageStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type CartCheckoutProps = {};
type CartDiscountProps = {};
type CartLineAttributeStyleProps = {
    typography?: TypographySetting;
};
type CartLineAttributeSidebarSettingProps = {
    styles: Pick<CartLineAttributeStyleProps, 'typography'>;
};
type CartLineAttributeProps = BaseProps<any, CartLineAttributeStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type CartLintPriceSettingProps = {
    priceType?: 'regular' | 'compare';
};
type CartLintPriceStyleProps = {
    typography?: TypographySetting;
};
type CartLinePriceSidebarSettingProps = {
    styles: Pick<CartLintPriceStyleProps, 'typography'>;
};
type CartLinePriceProps = BaseProps<CartLintPriceSettingProps, CartLintPriceStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type CartLineVariantStyleProps = {
    typography?: TypographySetting;
};
type CartLineVariantSidebarSettingProps = {
    styles: Pick<CartLineVariantStyleProps, 'typography'>;
};
type CartLineVariantProps = BaseProps<{}, CartLineVariantStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type CartListSettingProps = {
    itemPerPage?: number;
};
type CartListSidebarSettingProps = {
    setting: Pick<CartListSettingProps, 'itemPerPage'>;
    styles: Pick<ColStyleProps, 'order' | 'gap' | 'alignItem' | 'justifyContent'>;
};
type CartListProps = BaseProps<CartListSettingProps, ColStyleProps> & {
    children: React.ReactNode;
};
type CartOrderNoteSettingProps = {
    triggerUpdate?: 'blur' | 'debounce';
    debounce?: number;
    placeholder?: string;
};
type CartOrderNoteSidebarSettingProps = {
    setting: Pick<CartOrderNoteSettingProps, 'triggerUpdate' | 'debounce'>;
};
type CartOrderNoteProps = BaseProps<CartOrderNoteSettingProps>;
type CartTotalPriceSettingProps = {
    priceType?: 'total' | 'subtotal' | 'duty' | 'tax' | 'discount';
};
type CartTotalPriceStyleProps = {
    typography?: TypographySetting;
};
type CartTotalPriceProps = BaseProps<CartTotalPriceSettingProps, CartTotalPriceStyleProps>;
type CartTotalPriceSidebarSettingProps = {
    setting: Pick<CartTotalPriceSettingProps, 'priceType'>;
    styles: Pick<CartTotalPriceStyleProps, 'typography'>;
};
type CheckoutNowProps = BasePropsWrap<{
    openMode?: 'popup' | 'page';
    label?: string;
}, Pick<ButtonStyleProps, 'backgroundColor' | 'borderBtn' | 'textColor' | 'roundedBtn' | 'btnSpacing' | 'type' | 'typography' | 'width'>> & {
    className?: string;
};
type DiscountInputSettingProps = {
    label?: React.ReactNode;
    placeholder?: string;
};
type DiscountInputProps = BaseProps<DiscountInputSettingProps>;
type DiscountInputSidebarSettingProps = {
    setting: Pick<DiscountInputSettingProps, 'label' | 'placeholder'>;
};
type CouponListProps = {};
type CartTotalItemStyleProps = {
    typography?: TypographySetting;
};
type CartTotalItemSidebarSettingProps = {
    styles: Pick<CartTotalItemStyleProps, 'typography'>;
};
type CartTotalItemProps = BaseProps<{}, CartTotalItemStyleProps>;

declare const Cart: React.FC<CartProps>;

declare const CartList: React.FC<CartListProps>;

/**
 * The `CartLinePrice` component renders a `Money` component for the cart line merchandise's price or
 * compare at price. It must be a descendent of a `CartLineProvider` component.
 */
declare const CartLinePrice: React.FC<CartLinePriceProps>;

declare const CartLineVariant: React.FC<CartLineVariantProps>;

declare const CartLineImage: React.FC<CartLineImageProps>;

declare const CartTotalPrice: React.FC<CartTotalPriceProps>;

declare const CartTotalItem: React.FC<CartTotalItemProps>;

declare const CartCheckout: React.FC<CartCheckoutProps>;

declare const DiscountInput: React.FC<DiscountInputProps>;

declare const CartDiscount: React.FC<CartDiscountProps>;

declare const CartOrderNote: React$1.FC<CartOrderNoteProps>;

declare const CartLineAttribute: React.FC<CartLineAttributeProps>;

declare const CouponList: React.FC;

/**
 * The `ShopPayButton` component renders a button that redirects to the Shop Pay checkout.
 */
declare const ShopPayButton$1: React.FC<ShopPayButtonProps>;

declare const CheckoutNow: React.FC<CheckoutNowProps>;

declare const cartSetting: {
    Cart: _gem_sdk_core.ComponentSetting<CartSidebarSettingProps>;
    CartList: _gem_sdk_core.ComponentSetting<CartListSidebarSettingProps>;
    CartLinePrice: _gem_sdk_core.ComponentSetting<CartLinePriceSidebarSettingProps>;
    CartLineVariant: _gem_sdk_core.ComponentSetting<CartLineVariantSidebarSettingProps>;
    CartLineImage: _gem_sdk_core.ComponentSetting<CartLineImageSidebarSettingProps>;
    CartTotalPrice: _gem_sdk_core.ComponentSetting<CartTotalPriceSidebarSettingProps>;
    CartTotalItem: _gem_sdk_core.ComponentSetting<CartTotalItemSidebarSettingProps>;
    CartCheckout: _gem_sdk_core.ComponentSetting<CartCheckoutProps>;
    DiscountInput: _gem_sdk_core.ComponentSetting<DiscountInputSidebarSettingProps>;
    CartDiscount: _gem_sdk_core.ComponentSetting<CartDiscountProps>;
    CartOrderNote: _gem_sdk_core.ComponentSetting<CartOrderNoteSidebarSettingProps>;
    CartLineAttribute: _gem_sdk_core.ComponentSetting<CartLineAttributeSidebarSettingProps>;
    CouponList: _gem_sdk_core.ComponentSetting<CouponListProps>;
    ShopPayButton: _gem_sdk_core.ComponentSetting<ShopPayButtonSidebarSettingProps>;
};

type CSSCodeSettingProps = {
    editorData?: {
        customLabel?: string;
        html?: string;
        css?: string;
        javascript?: string;
        cssPlaceholder?: string;
    };
    background?: ObjectDevices<BackgroundMedia>;
    preloadBgImage?: boolean;
    align?: ObjectDevices<AlignProp>;
    customLabel?: string;
    speedParallax?: any;
};
type CSSCodeTranslateKeys = keyof CSSCodeSettingProps;
type CSSCodeProps = BasePropsWrap<CSSCodeSettingProps> & {
    advanced?: any;
    children?: React.ReactNode;
    pageContext?: PageContext;
};

declare const CSSCode$2: ({ setting, style, advanced, builderAttrs, builderProps, children, pageContext, }: CSSCodeProps) => React.JSX.Element;

declare const codeSetting: {
    CSSCode: _gem_sdk_core.ComponentSetting<CSSCodeProps>;
};

declare const CollectionTitle$1: React.FC<CollectionTitleProps>;

declare const CollectionBanner$1: React.FC<CollectionBannerProps>;

declare const CollectionDescription$2: React.FC<CollectionDescriptionProps>;

declare const CollectionToolbar$2: React.FC<CollectionToolbarProps>;

declare const CollectionPaginator$2: React.FC<CollectionPaginatorProps>;

declare const collectionSetting: {
    CollectionTitle: _gem_sdk_core.ComponentSetting<CollectionTitleProps>;
    CollectionBanner: _gem_sdk_core.ComponentSetting<CollectionBannerProps>;
    CollectionDescription: _gem_sdk_core.ComponentSetting<CollectionDescriptionProps>;
    CollectionToolbar: _gem_sdk_core.ComponentSetting<CollectionToolbarProps>;
    CollectionPaginator: _gem_sdk_core.ComponentSetting<CollectionPaginatorProps>;
};

type timerEverygreenType = {
    days: number;
    hours: number;
    mins: number;
    seconds?: number;
    endTime: number;
    startTime?: number;
};
type timerDailyType = {
    hours: number;
    mins: number;
    format: string;
};
type CountdownSettingProps = {
    enableDay?: boolean;
    enableWeek?: boolean;
    enableHour?: boolean;
    enableMinute?: boolean;
    enableSecond?: boolean;
    standardType?: string;
    dayLabel?: string;
    hourLabel?: string;
    minuteLabel?: string;
    secondLabel?: string;
    weekLabel?: string;
    behaviour: string;
    timerEverygreen?: timerEverygreenType;
    timerDaily?: timerDailyType;
    dateStandard?: number | string;
    autoHideWhenTimeout?: boolean;
    loopAfterFinish?: boolean;
    timeZone?: string | number;
    redirectUrl?: {
        type?: string;
        link?: string;
        target?: string;
    };
};
type CountdownStyleProps = {
    textAlign?: ObjectDevices<AlignProp>;
    borderColor?: StateProp<ColorValueType>;
    borderRadius?: string;
    minWidth?: string;
    colorNumber?: ColorValueType;
    colorLabel?: ColorValueType;
    enableNumberTextStyle?: boolean;
    enableLabelTextStyle?: boolean;
    padding?: ObjectDevices<SizeSettingGlobal>;
    /**
     * @deprecated use `numTypo` instead
     */
    numTypography?: TypographySetting;
    numTypo?: TypographySettingV2;
    /**
     * @deprecated use `labelTypo` instead
     */
    labelTypography?: TypographySetting;
    labelTypo?: TypographySettingV2;
    borderState?: StateProp<Border>;
    backgroundItemColor: ColorValueType;
    roundedState?: StateProp<CornerRadius>;
    verticalGap?: string;
    horizontalGap?: string;
    itemPadding?: ObjectDevices<PaddingType$2>;
};
type CountdownTimerTranslateKeys = keyof (CountdownSettingProps & CountdownStyleProps);
type CountdownProps = BaseProps<CountdownSettingProps, CountdownStyleProps> & {
    pageContext?: PageContext;
};

declare const Countdown$2: React.FC<CountdownProps>;

declare const countdownSetting: {
    Countdown: _gem_sdk_core.ComponentSetting<CountdownProps>;
};

type CouponSettingProps = {
    copyContent?: string;
    defaultLabel?: string;
    clickedLabel?: string;
    couponLayout?: string;
} & Pick<ButtonSettingProps, 'iconAlign' | 'iconSvg' | 'iconVisible' | 'shouldClearSpace' | 'enableHoverEffect' | 'enableActiveEffect'>;
type CouponStyleProps = ButtonStyleProps;
type CouponTranslateKeys = keyof (CouponSettingProps & CouponStyleProps);
type CouponProps = BasePropsWrap<CouponSettingProps, CouponStyleProps> & {
    children: React.ReactNode;
    translateSetting?: string;
} & {
    pageContext?: PageContext;
};

declare const Coupon$2: React.FC<CouponProps>;

declare const couponSetting: {
    Coupon: _gem_sdk_core.ComponentSetting<CouponProps>;
};

type DialogSettingProps = {
    name?: string;
    fullScreen?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
    trigger?: 'none' | 'show-on-page-load' | 'show-after-time' | 'show-after-scroll' | 'show-when-about-exit';
    mobileTrigger?: 'none' | 'timer';
    mobileTriggerTime?: number;
    dialogId?: string;
    triggerTime?: number;
    triggerPercentage?: number;
    frequencyMode?: 'once' | 'every' | 'after-period-time';
    frequency?: number;
    isOverlay?: boolean;
    overlayColor?: ColorValueType;
    overlayOpacity?: number;
    closeOnClickOutside?: boolean;
    closeButtonPosition?: 'inside' | 'outside';
    btnColor?: ColorValueType;
    btnBg?: ColorValueType;
    btnRounded?: CornerRadius;
    btnSize?: number;
    btnWidth?: ObjectDevices<string>;
    btnHeight?: ObjectDevices<string>;
    btnPadding?: ObjectDevices<PaddingType$2>;
    background?: ObjectDevices<BackgroundMedia>;
    iconSize?: string;
    iconSvg?: string;
    effectType?: 'fade' | 'zoom' | 'zoom-out' | 'horizontal' | 'vertical' | 'unfold' | 'none';
    position?: 'center' | 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left';
};
type DialogTranslateKeys = keyof DialogSettingProps;
type DialogProps$1 = BasePropsWrap<DialogSettingProps> & {
    children: React.ReactNode | string;
    pageContext?: PageContext;
};

declare const Dialog$2: (props: DialogProps$1) => React.JSX.Element;

declare const dialogSetting: {
    Dialog: _gem_sdk_core.ComponentSetting<DialogProps$1>;
};

type EstimateSettingProps = {
    htmlTag?: number;
    text?: string;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    background?: ObjectDevices<BackgroundMedia>;
    enableCustomText?: boolean;
    customText?: string;
    minEstimate?: number;
    maxEstimate?: number;
    estimateTime?: number;
    typeFormat?: string;
    customFormat?: string;
    typeEstimate?: string;
    ifOutOfStock?: string;
};
type EstimateStyleProps = {
    textShadowNotState?: ShadowProps;
    hasTextShadowNotState?: boolean;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typoCustom?: TypographySettingV2;
    typoDate?: TypographySettingV2;
    typo?: TypographySettingV2;
    textAlign?: ObjectDevices<AlignProp>;
    lineClamp?: ObjectDevices<number>;
    hasLineClamp?: ObjectDevices<boolean>;
    hasTextShadow?: StateProp<boolean>;
    textShadow?: StateProp<ShadowProps>;
    align?: ObjectDevices<AlignProp>;
    padding?: ObjectDevices<SizeSettingGlobal>;
    border?: ObjectDevices<StateProp<Border>>;
    rounded?: ObjectDevices<StateProp<CornerRadius>>;
    boxShadow?: ObjectDevices<StateProp<ShadowProps>>;
    shapeBorder?: ObjectDevices<Border>;
    shapeRounded?: ObjectDevices<CornerRadius>;
    shapeBoxShadow?: ObjectDevices<ShadowProps>;
};
type EstimateDateTranslateKeys = keyof EstimateSettingProps;
type EstimateDateProps = BasePropsWrap<EstimateSettingProps, EstimateStyleProps> & Omit<React.ComponentPropsWithoutRef<'h1'>, 'children'> & {
    children: React.ReactNode;
};

declare const EstimateDate$2: React.FC<EstimateDateProps>;

declare const estimateDeliverySetting: {
    EstimateDate: _gem_sdk_core.ComponentSetting<EstimateDateProps>;
};

type RootProps$1 = {
    children?: React.ReactNode;
};
declare const Root$1: React.FC<RootProps$1>;

declare const Section$2: React.FC<RowProps>;

declare const Row$2: React.FC<RowProps>;

declare const Column$1: React.FC<ColProps>;

declare const gridSetting: {
    Root: _gem_sdk_core.ComponentSetting<any>;
    Section: _gem_sdk_core.ComponentSetting<RowProps>;
    Row: _gem_sdk_core.ComponentSetting<RowProps>;
    Col: _gem_sdk_core.ComponentSetting<ColProps>;
};

type FormCheckboxSettingProps = {
    name?: string;
    description?: string;
    required?: boolean;
    selected?: boolean;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use `typo` instead
     */
    textColor?: ColorValueType;
    align?: ObjectDevices<AlignProp>;
    background?: ObjectDevices<BackgroundMedia>;
};
type FormCheckboxStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    borderRadius?: CornerRadius;
    border?: Border;
    wrapperBorder?: Border;
    hasActiveShadow?: boolean;
    shadow?: ShadowProps;
};
type FormCheckboxProps = BaseProps<FormCheckboxSettingProps, FormCheckboxStyleProps>;
type Advanced = any;
type TextAreaSettingProps = {
    text?: string;
    placeholder?: string;
    name?: string;
    required?: boolean;
    size?: SizeSetting;
    /**
     * @deprecated please use `width` 100%
     */
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use `typo` instead
     */
    color?: ColorValueType;
    transform?: TransformProp;
    align?: ObjectDevices<AlignProp>;
};
type TextAreaStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
};
type TextAreaProps = BasePropsWrap<TextAreaSettingProps, TextAreaStyleProps, Advanced> & Omit<React.ComponentPropsWithoutRef<'input'>, ''>;
type FormDropdownSettingProps = {
    name?: string;
    childItem?: string[];
    required?: boolean;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use `typo` instead
     */
    textColor?: ColorValueType;
    size?: SizeSetting;
    /**
     * @deprecated please use `width` 100%
     */
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    align?: ObjectDevices<AlignProp>;
    background?: ObjectDevices<BackgroundMedia>;
    placeholder?: string;
    placeholderColor?: ColorValueType;
    defaultOption?: string;
};
type FormDropdownStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    border?: ObjectDevices<StateProp<Border>>;
    borderActive?: StateProp<Border>;
    backgroundColorV2Active?: StateProp<ColorValueType>;
    roundedActive?: StateProp<CornerRadius>;
    boxShadowActive?: StateProp<ShadowProps>;
};
type FormDropdownProps = BasePropsWrap<FormDropdownSettingProps, FormDropdownStyleProps, Advanced> & {
    children: React.ReactNode;
};
type FormEmailSettingProps = {
    placeholder?: string;
    required?: boolean;
    hideOnClient?: boolean;
    defaultEmail?: string;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    size?: SizeSetting;
    /**
     * @deprecated please use `width` 100%
     */
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    align?: ObjectDevices<AlignProp>;
    wrapperBorder?: Border;
    background?: ObjectDevices<BackgroundMedia>;
    placeholderColor?: ColorValueType;
    title?: string;
    showTitle?: boolean;
};
type FormEmailStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    borderRadius?: CornerRadius;
    wrapperBorder?: Border;
    borderEmailHover?: StateProp<Border>;
    textColorHover?: StateProp<ColorValueType>;
    backgroundColorV2Hover?: StateProp<ColorValueType>;
    roundedEmailHover?: StateProp<CornerRadius>;
    boxShadowEmailHover?: StateProp<ShadowProps>;
    borderEmailActive?: StateProp<Border>;
    textColorActive?: StateProp<ColorValueType>;
    backgroundColorV2Active?: StateProp<ColorValueType>;
    roundedEmailActive?: StateProp<CornerRadius>;
    boxShadowEmailActive?: StateProp<ShadowProps>;
};
type FormEmailProps = BasePropsWrap<FormEmailSettingProps, FormEmailStyleProps, Advanced> & {
    children: React.ReactNode;
};
type NewsLetterSettingProps = {
    afterSubmitAction?: 'stay-on-page' | 'open-url';
    callbackURL?: {
        type?: string;
        link?: string;
        target?: string;
    };
    successMessage?: string;
    errorMessage?: string;
    successColor?: ColorValueType;
    errorColor?: ColorValueType;
    background?: ObjectDevices<BackgroundMedia>;
    size?: SizeSetting;
    width?: ObjectDevices<string | number | undefined>;
    afterSubmitActionToggle?: ObjectDevices<boolean>;
    contentBanner?: string;
};
type NewsLetterStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    border?: ObjectDevices<Border>;
    rounded?: ObjectDevices<CornerRadius>;
    boxShadow?: ObjectDevices<ShadowProps>;
};
type NewsletterProps = BasePropsWrap<NewsLetterSettingProps, NewsLetterStyleProps> & {
    children?: React.ReactNode;
    formType?: string;
    pageContext?: PageContext;
};
type OriginalSettingProps$7 = {
    layout?: 'default' | 'rounded' | 'bordered' | 'underlined';
    label?: string;
};
type SubmitButtonSettingProps = OriginalSettingProps$7 & Pick<ButtonSettingProps, 'iconAlign' | 'iconSvg' | 'iconVisible' | 'shouldClearSpace' | 'enableHoverEffect'>;
type SubmitButtonStyleProps = ButtonStyleProps;
type SubmitButtonProps = BasePropsWrap<SubmitButtonSettingProps, SubmitButtonStyleProps> & {
    children: React.ReactNode;
};
type TextFieldSettingProps = {
    text?: string;
    placeholder?: string;
    name?: string;
    required?: boolean;
    size?: SizeSetting;
    /**
     * @deprecated please use `width` 100%
     */
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use `typo` instead
     */
    color?: ColorValueType;
    transform?: TransformProp;
    align?: ObjectDevices<AlignProp>;
};
type TextFieldStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
};
type TextFieldProps = BasePropsWrap<TextFieldSettingProps, TextFieldStyleProps, Advanced> & Omit<React.ComponentPropsWithoutRef<'input'>, ''>;
type InputType = 'text' | 'textarea' | 'email' | 'phone' | 'number';
type TextInputSettingProps = {
    text?: string;
    placeholder?: string;
    name?: {
        text: string;
        textarea: string;
        number: string;
        phone: string;
        email: string;
    };
    required?: boolean;
    size?: SizeSetting;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    /**
     * @deprecated please use `typo` instead
     */
    color?: ColorValueType;
    transform?: TransformProp;
    align?: ObjectDevices<AlignProp>;
    background?: ObjectDevices<BackgroundMedia>;
    formType?: InputType;
    formConfiguration?: any;
    placeholderColor?: ColorValueType;
    textLine?: number;
};
type TextInputStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    borderRadius?: CornerRadius;
    border?: ObjectDevices<StateProp<Border>>;
    wrapperBorder?: Border;
    hasActiveShadow?: boolean;
    shadow?: ShadowProps;
};
type TextInputProps = BasePropsWrap<TextInputSettingProps, TextInputStyleProps, Advanced> & Omit<React.ComponentPropsWithoutRef<'input'>, ''>;

declare const Newsletter$2: ({ children, setting, styles, style, builderAttrs, builderProps, }: NewsletterProps) => React.JSX.Element;

declare const ContactForm$2: ({ children, styles, setting, style, builderAttrs, builderProps, }: NewsletterProps) => React.JSX.Element;

declare const FormEmail$2: ({ builderProps, builderAttrs, setting, advanced, children, styles, }: FormEmailProps) => React.JSX.Element;

declare const SubmitButton$2: ({ setting, builderProps, builderAttrs, style, styles, advanced, children, }: SubmitButtonProps) => React.JSX.Element;

declare const FormDropdown$2: ({ builderProps, builderAttrs, setting, advanced, children, styles, }: FormDropdownProps) => React.JSX.Element;

declare const TextField$2: React.FC<TextFieldProps>;

declare const FormTextArea: React.FC<TextAreaProps>;

declare const FormCheckbox$1: ({ builderProps, setting, advanced, styles }: FormCheckboxProps) => React.JSX.Element;

declare const TextInput$2: React.FC<TextInputProps>;

declare const contactFormSetting: {
    Newsletter: _gem_sdk_core.ComponentSetting<NewsletterProps>;
    FormEmail: _gem_sdk_core.ComponentSetting<FormEmailProps>;
    SubmitButton: _gem_sdk_core.ComponentSetting<SubmitButtonProps>;
    FormDropdown: _gem_sdk_core.ComponentSetting<FormDropdownProps>;
    TextField: _gem_sdk_core.ComponentSetting<TextFieldProps>;
    FormCheckbox: _gem_sdk_core.ComponentSetting<FormCheckboxProps>;
    TextInput: _gem_sdk_core.ComponentSetting<TextInputProps>;
    FormTextarea: _gem_sdk_core.ComponentSetting<TextAreaProps>;
    ContactForm: _gem_sdk_core.ComponentSetting<NewsletterProps>;
};

type MenuData = {
    ROOT: SubMenu;
} & Menu$1;
type SubMenu = {
    id: string;
    title: string;
    link?: string;
    childrens?: string[];
};
type Menu$1 = Record<string, SubMenu>;
type MenuSettingProps = {
    submenuStyle?: 'DropdownMenu' | 'MegaMenu';
    data?: MenuData;
};
type MenuStyleProps = {
    color?: StateProp<ColorValueType>;
    typography?: TypographySetting;
    textAlign?: ObjectDevices<AlignProp>;
    lineClamp?: ObjectDevices<number>;
    hasLineClamp?: ObjectDevices<boolean>;
    hasTextShadow?: StateProp<boolean>;
    textShadow?: StateProp<ShadowProps>;
    hasBoxShadow?: StateProp<boolean>;
    boxShadow?: StateProp<ShadowProps>;
    transform?: TransformProp;
};
type MenuProps = BaseProps<MenuSettingProps, MenuStyleProps>;

type HeaderStyle = 'basic' | 'morden';
type MenuItemProps = {
    id: string;
    menu?: MenuData;
    depth?: number;
    maxDepth?: number;
    arrow?: string;
    textColor?: StateProp<ColorValueType>;
    menuTextColor?: StateProp<ColorValueType>;
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    closeMenu?: () => void;
    menuBg?: ObjectDevices<ColorValueType>;
    headerBg?: ObjectDevices<ColorValueType>;
    enableHoverEffect?: boolean;
    enableDropdownHoverEffect?: boolean;
};
type HeaderOriginalSettingProps = {
    logo?: NonNullable<ImageProps['setting']>['srcSet'];
    logoWidth?: ObjectDevices<string>;
    logoAspectRatio?: ObjectDevices<string>;
    customAspectRadio?: ObjectDevices<Ratio>;
    layout?: ObjectDevices<ObjectFit$2>;
    breakpoint?: 'tablet' | 'mobile' | 'desktop';
    cartIcon?: string;
    openMode?: 'popup' | 'page';
    buyNow?: boolean;
    cardEnableHoverEffect?: boolean;
    itemEnableHoverEffect?: boolean;
    enableDropdownHoverEffect?: boolean;
};
type HeaderSettingProps = HeaderOriginalSettingProps & Pick<MenuItemProps, 'arrow' | 'menu'>;
type HeaderStyleProps = {
    height?: ObjectDevices<string>;
    cartIconColor?: StateProp<ColorValueType>;
    btnType?: 'primary' | 'secondary';
    btnRounded?: StateProp<CornerRadius>;
    btnBgColor?: StateProp<ColorValueType>;
    btnTextColor?: StateProp<ColorValueType>;
    btnWidth?: ObjectDevices<string | number | undefined>;
    btnTypography?: TypographySetting;
    btnSpacing?: SizeSetting;
    btnBorder?: StateProp<Border>;
} & Pick<MenuItemProps, 'typography' | 'typo' | 'menuTextColor' | 'menuBg' | 'headerBg' | 'textColor'>;
type HeaderCommonProps = HeaderSettingProps & HeaderStyleProps;
type HeaderProps = BasePropsWrap<HeaderSettingProps & {
    kind?: HeaderStyle;
}, HeaderStyleProps> & {
    children: React.ReactNode;
};

declare const Header: ({ builderAttrs, builderProps, style, setting, styles, children }: HeaderProps) => React.JSX.Element | null;

type Props$2 = HeaderCommonProps;
declare const BasicHeader: ({ btnBgColor, btnBorder, btnRounded, btnSpacing, btnTextColor, btnTypography, btnType, btnWidth, openMode, buyNow, breakpoint, ...props }: Props$2) => React.JSX.Element;

declare const ModernHeader: (props: HeaderCommonProps) => React.JSX.Element;

type Props$1 = Pick<HeaderCommonProps, 'menu' | 'arrow' | 'typo' | 'typography' | 'menuTextColor' | 'height' | 'menuBg' | 'textColor' | 'itemEnableHoverEffect'> & {
    className?: string;
};
declare const MobileMenu: ({ menu, typography, typo, arrow, menuTextColor, menuBg, textColor, className, itemEnableHoverEffect, }: Props$1) => React.JSX.Element;

type Props = Pick<HeaderCommonProps, 'menu' | 'arrow' | 'typography' | 'typo' | 'headerBg' | 'menuTextColor' | 'height' | 'menuBg' | 'textColor' | 'itemEnableHoverEffect' | 'enableDropdownHoverEffect'> & {
    className?: string;
};
declare const DesktopMenu: ({ menu, height, arrow, textColor, menuTextColor, typography, typo, headerBg, menuBg, className, itemEnableHoverEffect, enableDropdownHoverEffect, }: Props) => React.JSX.Element;

declare const headerSetting: {
    Header: _gem_sdk_core.ComponentSetting<HeaderProps>;
};

type HeadingSettingProps = {
    htmlTag?: number;
    text?: string;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    background?: ObjectDevices<BackgroundMedia>;
};
type HeadingStyleProps = {
    textShadowNotState?: ShadowProps;
    hasTextShadowNotState?: boolean;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    textAlign?: ObjectDevices<AlignProp>;
    lineClamp?: ObjectDevices<number>;
    hasLineClamp?: ObjectDevices<boolean>;
    hasTextShadow?: StateProp<boolean>;
    textShadow?: StateProp<ShadowProps>;
    align?: ObjectDevices<AlignProp>;
    shapeBorder?: ObjectDevices<Border>;
    shapeRounded?: ObjectDevices<CornerRadius>;
    shapeBoxShadow?: ObjectDevices<ShadowProps>;
};
type HeadingTranslateKeys = keyof (HeadingSettingProps & HeadingStyleProps);
type HeadingProps = BasePropsWrap<HeadingSettingProps, HeadingStyleProps> & Omit<React.ComponentPropsWithoutRef<'h1'>, 'children'> & {
    children: React.ReactNode;
};

declare const Heading$2: React.FC<HeadingProps>;

declare const headingSetting: {
    Heading: _gem_sdk_core.ComponentSetting<HeadingProps>;
};

type IconSettingProps = {
    iconSvg?: string;
    iconLinkEnable?: boolean;
    iconLink?: {
        type?: string;
        link?: string;
        target?: string;
        title?: string;
        noFollow?: boolean;
    };
};
type IconStyleProps = {
    iconHeight?: string | number;
    iconSize?: ObjectDevices<Ratio>;
    align?: ObjectDevices<AlignProp>;
    iconWidth?: ObjectDevices<string | number>;
    bgColor?: StateProp<ColorValueType>;
    color?: StateProp<ColorValueType>;
    iconBorder?: StateProp<Border>;
    iconRotate?: number;
    spin?: boolean;
    iconRounded?: StateProp<CornerRadius>;
    iconSpacing?: SizeSetting;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    iconShadow?: ShadowProps;
};
type IconProps = BasePropsWrap<IconSettingProps, IconStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
} & {
    advanced?: any;
} & Omit<React.ComponentPropsWithoutRef<'div'>, ''>;

declare const Icon$1: React$1.FC<IconProps>;

declare const iconSetting: {
    Icon: _gem_sdk_core.ComponentSetting<IconProps>;
};

type IconListSettingProps$1 = {
    childItem?: string[];
    preload?: boolean;
};
type IconListStyleProps$1 = {
    background?: ObjectDevices<Background>;
    align?: ObjectDevices<AlignProp>;
    alignWrapper?: ObjectDevices<AlignProp>;
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    verticalSpacing?: ObjectDevices<Property.Padding>;
    itemPadding?: ObjectDevices<SizeSettingGlobal>;
    itemBackgroundColor?: ObjectDevices<ColorValueType>;
    itemBorder?: ObjectDevices<Border>;
    itemBoxShadow?: ObjectDevices<ShadowProps>;
    itemRounded?: ObjectDevices<CornerRadius>;
    globalSize?: ObjectDevices<SizeSettingGlobal>;
};
type IconListTranslateKeys = keyof (IconListSettingProps$1 & IconListStyleProps$1);
type IconListProps$1 = BasePropsWrap<IconListSettingProps$1, IconListStyleProps$1> & {
    children?: React.ReactNode;
    rawChildren?: any[];
    advanced?: any;
    pageContext?: PageContext;
};
type IconListItemProps$1 = BasePropsWrap & React.ComponentPropsWithoutRef<'div'> & {
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    parentUid?: string;
    dataIndex?: number;
    index?: number;
    parentStyles?: IconListProps$1['styles'];
};

declare const IconList$2: React$1.FC<IconListProps$1>;

declare const IconListItem$1: React$1.FC<IconListItemProps$1>;

declare const iconListSetting: {
    IconList: _gem_sdk_core.ComponentSetting<IconListProps$1>;
    IconListItem: _gem_sdk_core.ComponentSetting<IconListItemProps$1>;
};

type IconListHozSettingProps = {
    childItem?: string[];
    preload?: boolean;
};
type IconListHozStyleProps = {
    background?: ObjectDevices<Background>;
    align?: ObjectDevices<AlignProp>;
    verticalAlign?: ObjectDevices<'start' | 'end' | 'center' | 'space-between'>;
    horizontalSpacing?: Property.Padding;
};
type IconListHozProps = BasePropsWrap<IconListHozSettingProps, IconListHozStyleProps> & {
    children?: React.ReactNode;
};
type IconListItemProps = BasePropsWrap & React.ComponentPropsWithoutRef<'div'> & {
    horizontalSpacing?: ObjectDevices<Property.Padding>;
};

declare const IconListHoz$1: React$1.FC<IconListHozProps>;

declare const IconListHozItem: React$1.FC<IconListItemProps>;

declare const iconListHozSetting: {
    IconListHoz: _gem_sdk_core.ComponentSetting<IconListHozProps>;
    IconListItemHoz: _gem_sdk_core.ComponentSetting<IconListItemProps>;
};

type IconListSettingProps = {
    childItem?: string[];
    textTypo?: TypographySettingV2;
    iconSvg?: string;
    iconWidth?: ObjectDevices<number>;
    childConfig?: string[];
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    iconType?: 'matching' | 'different';
};
type IconListStyleProps = {
    horizontalSpacing?: ObjectDevices<Property.Padding>;
    verticalSpacing?: ObjectDevices<Property.Padding>;
    position?: ObjectDevices<'center' | 'baseline'>;
    align?: ObjectDevices<AlignProp>;
    iconColor?: ColorValueType;
    backgroundColor?: ColorValueType;
    iconBorder?: Border;
    iconRounded?: CornerRadius;
    background?: ObjectDevices<Background>;
    panelAlign?: ObjectDevices<AlignProp>;
    contentBoxWidth?: ObjectDevices<string | number>;
    contentBoxPadding?: ObjectDevices<PaddingType$2>;
    contentBoxBorder?: ObjectDevices<Border>;
    contentBoxRounded?: ObjectDevices<CornerRadius>;
    contentBoxShadow?: ObjectDevices<ShadowProps>;
};
type IconListV2TranslateKeys = keyof (IconListSettingProps & IconListStyleProps);
type IconListProps = BasePropsWrap<IconListSettingProps, IconListStyleProps> & {
    pageContext?: PageContext;
};

declare const IconListV2$2: React.FC<IconListProps>;

declare const iconListSettingV2: {
    IconListV2: _gem_sdk_core.ComponentSetting<IconListProps>;
};

type ImageComparisonItem = {
    src?: string;
    width?: number;
    height?: number;
    backupFileKey?: string;
    backupFilePath?: string;
    storage?: IImageStorageType;
    metafieldDefinitionKey?: string;
};
type ImageTab = 'left' | 'right';
type ImageComparisonSettingProps = {
    imageLeft: ImageComparisonItem;
    imageRight: ImageComparisonItem;
    altLeft?: string;
    altRight?: string;
    titleLeft?: string;
    titleRight?: string;
    imageLinkLeft?: {
        link?: string;
        target?: string;
    };
    imageLinkRight?: {
        link?: string;
        target?: string;
    };
    direction: string;
    defaultPercentage?: number;
    leftImageLabel?: string;
    rightImageLabel?: string;
    sliderLineWidth?: number;
    hoverToSlide?: boolean;
    imageTab?: ImageTab;
    seoTab?: ImageTab;
    enableLabel?: boolean;
    preload?: boolean;
    qualityType?: ObjectDevices<QualityType$2>;
    qualityPercent?: ObjectDevices<number>;
    enableSEOLeft?: boolean;
    enableSEORight?: boolean;
};
type QualityType$2 = 'finest' | 'high' | 'medium' | 'custom';
type ImageComparisonStyleProps = {
    labelPadding?: ObjectDevices<PaddingType$2>;
    labelTextColor?: ColorValueType;
    labelBackgroundColor?: ObjectDevices<ColorValueType>;
    labelBorder?: ObjectDevices<Border>;
    labelRounded?: ObjectDevices<CornerRadius>;
    labelShadow?: ObjectDevices<ShadowProps>;
    align?: ObjectDevices<AlignProp>;
    typo?: TypographySettingV2;
    transform?: string;
    spacing?: string;
    customAspectRadio?: ObjectDevices<Ratio>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<number | string>;
    imageScale?: ObjectDevices<ObjectFit$2>;
    labelPositionHoz?: ObjectDevices<string>;
    labelPositionVer?: ObjectDevices<string>;
} & Pick<SharedProps, 'aspectRatio'>;
type ImageComparisonTranslateKeys = keyof (ImageComparisonSettingProps & ImageComparisonStyleProps);
type ImageComparisonProps = BaseProps<ImageComparisonSettingProps, ImageComparisonStyleProps> & {
    className?: string;
    pageContext?: PageContext;
};

declare const ImageComparison$2: React.FC<ImageComparisonProps>;

declare const imageComparisonSetting: {
    ImageComparison: _gem_sdk_core.ComponentSetting<ImageComparisonProps>;
};

type ImageDetectionSettingProps = {
    imagePreviewUrl?: string;
    timeout?: number;
    loading?: boolean;
    error?: string;
};
type ImageDetectionProps = BaseProps<ImageDetectionSettingProps>;

declare const ImageDetection: React$1.FC<ImageDetectionProps>;

declare const imageDetectionSetting: {
    ImageDetection: _gem_sdk_core.ComponentSetting<ImageDetectionProps>;
};

type InputSettingProps = {
    type?: 'text' | 'number' | 'password' | 'email' | 'hidden' | 'search' | 'tel' | 'url';
    defaultValue?: string;
    placeholder?: string;
    disabled?: boolean;
    prefix?: string;
    suffix?: string;
    allowClear?: boolean;
    passwordToggle?: boolean;
    required?: boolean;
};
type InputProps = BasePropsWrap<InputSettingProps> & {
    className?: string;
    style?: React.CSSProperties;
    id?: string;
};

declare const Input: React.FC<InputProps>;

declare const inputSetting: {
    Input: _gem_sdk_core.ComponentSetting<InputProps>;
};

type LineSettingProps = {
    enableIconText?: ObjectDevices<boolean>;
    text?: string;
    iconSvg?: string;
    position?: AlignProp;
};
type LineStyleProps = {
    lineStyle: ObjectDevices<string>;
    color?: ColorValueType;
    thickness?: ObjectDevices<string | number>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number>;
    align?: ObjectDevices<AlignProp>;
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    textColor?: ColorValueType;
    textSpacing?: string | number;
    iconSize?: ObjectDevices<string | number>;
    iconRotate?: string | number;
    iconColor?: ColorValueType;
    iconSpacing?: string | number;
    transform?: string | number;
    customTransform?: string | number;
};
type LineProps = {
    children?: React.ReactNode;
    className?: string;
} & BaseProps<LineSettingProps, LineStyleProps>;

declare const Line$2: React.FC<LineProps>;

declare const lineSetting: {
    Line: _gem_sdk_core.ComponentSetting<LineProps>;
};

type LinkSettingProps = {
    type?: 'auto' | 'product' | 'collection' | 'custom';
    label?: string;
    noFollow?: boolean;
    target?: HTMLAnchorElement['target'];
    href?: HTMLAnchorElement['href'];
};
type LinkProps = BaseProps<LinkSettingProps> & {
    className?: string;
    style?: React.CSSProperties;
    children?: React.ReactNode;
    title?: string;
    dataId?: string;
};
type MixedNextProps = BaseProps<{
    type?: 'auto' | 'product' | 'collection' | 'custom';
    target?: HTMLAnchorElement['target'];
    href?: HTMLAnchorElement['href'];
}>;
type NextLinkProps = MixedNextProps & {
    className?: string;
    style?: React.CSSProperties;
};

declare const Link$1: React.FC<LinkProps>;

declare const linkSetting: {
    Link: _gem_sdk_core.ComponentSetting<LinkProps>;
};

type MarqueeSettingProps = {
    childItem?: string[];
    isShowIconSeparator?: boolean;
    iconSeparatorSvg?: string;
    stopOnHover?: boolean;
    speed?: number;
    direction?: 'left' | 'right';
    isPreview?: boolean;
    hasItemShadow?: boolean;
    activeItem?: string;
    hoverItem?: string;
    itemWidthType?: ObjectDevices<'FIT_CONTENT' | 'BASE_ON_NUMBER_OF_ITEMS' | 'CUSTOM'>;
};
type MarqueeStyleProps = {
    itemSpacing?: ObjectDevices<string>;
    itemMaxWidth?: ObjectDevices<string>;
    iconSeparatorSize?: ObjectDevices<number>;
    iconSeparatorColor?: ColorValueType;
    itemBorderStyle?: Border;
    itemCorner?: CornerRadius;
    itemBackgroundColor?: ObjectDevices<ColorValueType>;
    backgroundColor?: ObjectDevices<ColorValueType>;
    align?: ObjectDevices<AlignProp>;
    itemShadow?: ShadowProps;
    sizeSetting?: ObjectDevices<SizeSettingGlobal>;
};
type MarqueeProps = BasePropsWrap<MarqueeSettingProps, MarqueeStyleProps> & {
    children: React.ReactNode;
} & {
    rawChildren: RawChild[];
};
type MarqueeItemProps = {
    itemBorderStyle?: Border;
    itemCorner?: CornerRadius;
    itemBackgroundColor?: ObjectDevices<ColorValueType>;
    hasItemShadow?: boolean;
    itemShadow?: ShadowProps;
    index?: number;
    activeItem?: string;
    hoverItem?: string;
    timeToScroll: number;
    setHoverItem: (value?: string) => void;
    setActiveItem: (value?: string) => void;
    itemStyle?: Record<string, string>;
} & BasePropsWrap & React.ComponentPropsWithoutRef<'div'>;

declare const Marquee$1: ({ children, style, builderAttrs, advanced, ...props }: MarqueeProps) => React.JSX.Element;

declare const _default$5: React$1.NamedExoticComponent<MarqueeItemProps>;

declare const marqueeSetting: {
    Marquee: _gem_sdk_core.ComponentSetting<MarqueeProps>;
    MarqueeItem: _gem_sdk_core.ComponentSetting<MarqueeItemProps>;
};

declare const Menu: React.FC<MenuProps>;

declare const menuSetting: {
    Menu: _gem_sdk_core.ComponentSetting<MenuProps>;
};

type ModalSettingProps = {
    open?: boolean;
};
type ModalStyleProps = {
    width?: number | string;
};
type ModalProps = BaseProps<ModalSettingProps, ModalStyleProps> & {
    closeOnClickOutside?: boolean;
    closeOnEscape?: boolean;
    keyCodeForClose?: string[];
    willUnmount?: () => void;
    onClose?: () => void;
    onKeypressEscape?: (e: KeyboardEvent) => void;
    unmount?: boolean;
    children: React.ReactNode;
    disableIframeClickEvent?: boolean;
    contentClass?: string;
};
type ButtonConfig = {
    label?: string;
    onClick?: () => void;
    className?: string;
    settings?: ButtonProps['setting'];
    styles?: ButtonProps['styles'];
};
type DialogProps = {
    title?: React.ReactNode;
    content?: React.ReactNode;
    buttons: ButtonConfig[];
    closeOnClickOutside?: boolean;
    closeOnEscape?: boolean;
    keyCodeForClose?: string[];
    willUnmount?: () => void;
    afterClose?: () => void;
    onClickOutside?: () => void;
    onKeypressEscape?: (e: KeyboardEvent) => void;
    overlayClassName?: string;
    className?: string;
    dialogId?: string;
};

declare function openConfirm(properties: DialogProps): void;

declare const Modal: React.FC<ModalProps>;

declare const modalSetting: {
    Modal: _gem_sdk_core.ComponentSetting<ModalProps>;
};

type NoticeConfig = {
    type?: 'info' | 'success' | 'error' | 'warning' | 'default';
    content?: React.ReactNode;
    duration?: number | null;
    closeIcon?: React.ReactNode;
    closable?: boolean;
    className?: string;
    style?: React.CSSProperties;
    /** @private Internal usage. Do not override in your code */
    props?: React.HTMLAttributes<HTMLDivElement> & Record<string, any>;
    onClose?: VoidFunction;
    onClick?: React.MouseEventHandler<HTMLDivElement>;
};
type OpenConfig = NoticeConfig & {
    key: React.Key;
    placement?: Placement;
    content?: React.ReactNode;
    duration?: number | null;
};
type Placement = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right';
type NotificationConfig = {
    getContainer?: () => HTMLElement;
    closeIcon?: React.ReactNode;
    closable?: boolean;
    maxCount?: number;
    duration?: number;
    /** @private Trigger when all the notification closed. */
    onAllRemoved?: VoidFunction;
};
type OptionalConfig = Partial<OpenConfig>;
type NotificationAPI = {
    open: (config: OptionalConfig) => void;
    close: (key: React.Key) => void;
    destroy: () => void;
};

declare function useNotification(rootConfig?: NotificationConfig): [NotificationAPI, React.ReactElement];

declare const Notify: React.ForwardRefExoticComponent<Omit<NoticeConfig, "onClose"> & {
    className?: string;
    style?: React.CSSProperties;
    eventKey: React.Key;
    onClick?: React.MouseEventHandler<HTMLDivElement>;
    onNoticeClose?: (key: React.Key) => void;
} & React.RefAttributes<HTMLDivElement>>;

type PaginationSettingProps = {
    defaultCurrent?: number;
    total?: number;
    disabled?: boolean;
    pageSize?: number;
    align?: ObjectDevices<AlignProp>;
};
type PaginationProps = BaseProps<PaginationSettingProps> & {
    className?: string;
    style?: React.CSSProperties;
};

declare const Pagination: React.FC<PaginationProps>;

declare const paginationSetting: {
    Pagination: _gem_sdk_core.ComponentSetting<PaginationProps>;
};

type AdvancedListSettingProps = {
    childItem?: string[];
};
type AdvancedListStyleProps = {
    align?: Omit<AlignProp, 'justify'>;
    horizontalSpacing?: ObjectDevices<string>;
    verticalSpacing?: string;
};
type PostPurchaseAdvancedListProps = BasePropsWrap<AdvancedListSettingProps, AdvancedListStyleProps> & {
    children?: ReactNode;
};
type PostPurchaseAdvancedListItemProps = BasePropsWrap & React.ComponentPropsWithoutRef<'div'> & {
    horizontalSpacing?: ObjectDevices<string>;
};

declare const PostPurchaseAdvancedList: React.FC<PostPurchaseAdvancedListProps>;

declare const PostPurchaseAdvancedListItem: React.FC<PostPurchaseAdvancedListItemProps>;

declare const postPurchaseAdvancedListSetting: {
    PostPurchaseAdvancedList: _gem_sdk_core.ComponentSetting<PostPurchaseAdvancedListProps>;
    PostPurchaseAdvancedListItem: _gem_sdk_core.ComponentSetting<PostPurchaseAdvancedListItemProps>;
};

type PostPurchaseButtonSettingProps = {
    text?: string | number;
    buttonType?: 'primary' | 'secondary' | 'link';
    outOfStockLabel?: string;
    requireAcceptTermLabel?: string;
};
type PostPurchaseButtonStyleProps = {
    typo?: PostPurchaseTypo;
    align?: 'start' | 'end' | 'center';
    width?: ObjectDevices<string>;
    direction?: 'ltr' | 'rtl';
};
type PostPurchaseButtonProps = BasePropsWrap<PostPurchaseButtonSettingProps, PostPurchaseButtonStyleProps>;

declare const Button$2: ({ styles, builderAttrs, style, setting, advanced, builderProps, disabled, ...props }: PostPurchaseButtonProps & {
    disabled: boolean;
}) => React.JSX.Element;

declare const postPurchaseButtonSetting: {
    PostPurchaseButton: _gem_sdk_core.ComponentSetting<PostPurchaseButtonProps>;
};

type TStatus = 'info' | 'success' | 'warning' | 'critical' | 'none';
type BackgroundColor = {
    backgroundColor: TStatus | '';
};
type CalloutBoxProps = RowProps & {
    styles: BackgroundColor;
};
type CalloutTextSettingProps = {
    message?: string;
};
type CalloutTextStyleProps = {
    typo?: PostPurchaseTypo;
    width?: ObjectDevices<string>;
    textAlign?: 'left' | 'center' | 'right' | 'justify';
    align?: 'left' | 'right' | 'center';
    direction?: 'ltr' | 'rtl';
};
type CalloutTextProps = BasePropsWrap<CalloutTextSettingProps, CalloutTextStyleProps> & {
    children?: ReactNode;
};

declare const CalloutBox: (props: CalloutBoxProps) => React.JSX.Element;

declare const CalloutText: ({ setting, styles, style, builderAttrs, builderProps, children, }: CalloutTextProps) => React.JSX.Element;

declare const postPurchaseCalloutBoxSetting: {
    PostPurchaseCalloutBox: _gem_sdk_core.ComponentSetting<CalloutBoxProps>;
    PostPurchaseCalloutText: _gem_sdk_core.ComponentSetting<CalloutTextProps>;
};

type PostPurchaseTextColor = 'critical' | 'warning' | 'success' | 'defaultButton' | 'defaultLink' | 'default' | 'boldDefault' | 'info' | undefined;

type CountdownTimerSettingProps = {
    conditionText?: string;
    expired?: string;
    expiredText?: string;
    whenTimeOut?: string;
};
type CountdownTimerStyleProps = {
    typo?: PostPurchaseTypo;
    width?: ObjectDevices<string>;
    textAlign?: 'left' | 'center' | 'right' | 'justify';
    align?: 'left' | 'right' | 'center';
    bgColor?: PostPurchaseTextColor;
    direction?: 'ltr' | 'rtl';
};
type PostPurchaseCountdownTimerProps = BasePropsWrap<CountdownTimerSettingProps, CountdownTimerStyleProps>;

declare const PostPurchaseCountdownTimer: React.FC;

declare const postPurchaseCountdownTimerSetting: {
    PostPurchaseCountdownTimer: _gem_sdk_core.ComponentSetting<PostPurchaseCountdownTimerProps>;
};

type ImageData = {
    alt?: string;
    src?: string;
    width?: number;
    height?: number;
    base64?: string;
    backupFileKey?: string;
};
type ImageSettingProps = {
    srcSet?: ObjectDevices<ImageData>;
    alt?: string;
    priority?: boolean;
    quality?: number | `${number}`;
};
type ObjectFit = 'cover' | 'contain';
type ImageStyleProps = {
    aspectRatio?: string;
    objectFit?: ObjectFit;
    width?: ObjectDevices<string>;
    align?: AlignProp;
    enableBorder?: 'none' | 'solid';
};
type PostPurchaseImageProps = BasePropsWrap<ImageSettingProps, ImageStyleProps> & {
    className?: string;
    children?: React.ReactNode;
    onClick?: React.MouseEventHandler<any>;
} & {
    advanced?: any;
};

declare const PostPurchaseImage: React.FC<PostPurchaseImageProps>;

declare const postPurchaseImageSetting: {
    PostPurchaseImage: _gem_sdk_core.ComponentSetting<PostPurchaseImageProps>;
};

declare enum ThicknessUnit {
    thin = 1,
    medium = 3,
    thick = 5,
    xthick = 10
}
type PostPurchaseLineSettingProps = {
    enableIconText?: ObjectDevices<boolean>;
    text?: string;
    iconSvg?: string;
    position?: AlignProp;
};
type PostPurchaseLineStyleProps = {
    thickness?: keyof typeof ThicknessUnit;
    width?: ObjectDevices<string>;
    align?: 'left' | 'center' | 'right';
};
type PostPurchaseLineProps = BasePropsWrap<PostPurchaseLineSettingProps, PostPurchaseLineStyleProps> & {
    children?: React.ReactNode;
    className?: string;
};

declare const Line$1: React.FC<PostPurchaseLineProps>;

declare const postPurchaseLineSetting: {
    PostPurchaseLine: _gem_sdk_core.ComponentSetting<PostPurchaseLineProps>;
};

type PostPurchaseLinkSettingProps = {
    link?: string;
    label?: string;
};
type PostPurchaseLinkStyleProps = {
    align?: 'left' | 'center' | 'right';
    typo?: PostPurchaseTypo;
    textAlign?: 'left' | 'center' | 'right';
    width?: ObjectDevices<string>;
    direction?: 'ltr' | 'rtl';
};
type PostPurchaseLinkProps = BasePropsWrap<PostPurchaseLinkSettingProps, PostPurchaseLinkStyleProps>;

declare const Link: React.FC<PostPurchaseLinkProps>;

declare const postPurchaseLinkSetting: {
    PostPurchaseLink: _gem_sdk_core.ComponentSetting<PostPurchaseLinkProps>;
};

type PostPurchaseTextSettingProps = {
    text?: string | number;
    options?: SettingOptions;
};
type PostPurchaseTextStyleProps = {
    typo?: PostPurchaseTypo;
    width?: ObjectDevices<string>;
    textAlign?: AlignItemProp;
    align?: AlignItemProp;
    direction?: 'ltr' | 'rtl';
};
type PostPurchaseTextProps = BasePropsWrap<PostPurchaseTextSettingProps, PostPurchaseTextStyleProps> & Omit<React.ComponentPropsWithoutRef<'p'>, ''> & {
    textClassWrapper?: string;
    textClass?: string;
};
type SettingOptions = {
    uniqueId?: string;
    useState?: boolean;
    productID?: string;
    isCannotEditing?: boolean;
};

declare const Text$3: ({ styles, builderAttrs, style, setting, advanced, builderProps, className, children, textClassWrapper, textClass, ...props }: PostPurchaseTextProps) => React.JSX.Element;

declare const PostPurchaseHeading: ({ styles, builderAttrs, style, setting, advanced, builderProps, className, children, textClassWrapper, textClass, ...props }: PostPurchaseTextProps) => React.JSX.Element;
declare const postPurchaseTextSetting: {
    PostPurchaseText: _gem_sdk_core.ComponentSetting<PostPurchaseTextProps>;
    PostPurchaseHeading: _gem_sdk_core.ComponentSetting<PostPurchaseTextProps>;
};

type OriginalSettingProps$6 = {
    isAuto?: boolean;
    productSetting?: {
        productId?: string;
        productStatus?: string;
        initialVariantId?: string;
        initialVariantBaseId?: string;
        productHandle?: string;
        selectedOptions?: {
            name: string;
            value: string;
            optionType: string;
            valueBaseID: string;
        }[];
        hasPreSelected?: boolean;
    };
    discountType?: 'PERCENTAGE' | 'FIXED_AMOUNT';
    discountValue?: number;
    shippingFeeType?: 'free' | 'fixedChange' | 'chargePerUnit';
    shippingFeeValue?: number;
    ssr?: boolean;
    isSyncProduct?: boolean;
};
type ProductSettingProps = OriginalSettingProps$6 & Omit<ProductProviderProps, 'product' | 'initialVariantId'> & RowSettingProps;
type ProductStyleProps = RowStyleProps;
type ProductProps = BasePropsWrap<ProductSettingProps, ProductStyleProps> & {
    children: React.ReactNode;
    rawChildren?: any[];
};

type PreVariantSelected = Record<string, {
    variantId: string;
    optionSelected: Record<string, string>;
}>;
type ProductOfferSettingProps = {
    productSetting?: {
        productIds?: string[];
    };
    productOfferLayout: ObjectDevices<'1col' | '2col'>;
    dynamicOfferQuantity?: number;
    discountAndShippingFee?: boolean;
    variantSelected?: PreVariantSelected;
} & Omit<ProductSettingProps, 'productSetting'>;
type ProductOfferStyleProps = RowStyleProps & {
    productOfferColumnGap?: ObjectDevices<string>;
    productOfferVerticalGutter?: string;
    productOfferFullWidth?: ObjectDevices<boolean>;
    productOfferWidth?: ObjectDevices<string>;
};
type PostPurchaseProductOfferProps$1 = BasePropsWrap<ProductOfferSettingProps, ProductOfferStyleProps> & {
    children: React.ReactNode;
};

type ProductOfferSettings = Omit<ProductSettingProps, 'productSetting'> & {
    productSetting?: {
        productIds?: string[];
    };
    productOfferLayout: ObjectDevices<'1col' | '2col'>;
    dynamicOfferQuantity?: number;
    discountAndShippingFee?: boolean;
    variantSelected?: PreVariantSelected;
};
type ProductOfferStyles = RowProps['styles'] & {
    productOfferColumnGap?: ObjectDevices<string>;
    productOfferVerticalGutter?: string;
    productOfferFullWidth?: ObjectDevices<boolean>;
    productOfferWidth?: ObjectDevices<string>;
};
type PostPurchaseProductOfferProps = BasePropsWrap<ProductOfferSettings, ProductOfferStyles> & {
    children: React.ReactNode;
};

declare const PostPurchaseProductOffer: React.FC<PostPurchaseProductOfferProps>;

type VariantTypeof$1 = 'dropdown' | 'rectangle_list' | 'image_shopify' | 'color' | 'image' | string;
type VariantBaseSetting$1 = {
    fullWidth?: Partial<Record<NameDevices, boolean>>;
    width?: Partial<Record<NameDevices, string>>;
    height?: string;
    spacing?: string;
    labelToggle?: boolean;
    labelTextSize?: string;
    labelTransform?: string;
    numberPerRow?: number;
    itemSpacing?: string;
};

type Spacing = 'none' | 'xtight' | 'tight' | 'loose' | 'xloose' | undefined;

type PostPurchaseProductVariantSettingProps = {
    optionType?: 'singleOption' | 'groupOption';
    variantPresets?: VariantPreset$1[];
    enableVariant?: boolean;
    label?: boolean;
    price?: boolean;
    showAsSwatches?: boolean;
    layout?: ObjectDevices<string>;
    column?: ObjectDevices<string | number>;
    hasPreSelected?: boolean;
    blankText?: string;
    combineHeight?: string | number;
    combineFullWidth?: ObjectDevices<boolean>;
    combineWidth?: ObjectDevices<string | number>;
    soldOutStyle?: string;
    soldOutMark?: boolean;
};
type PostPurchaseProductVariantStyleProps = {
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number>;
    align?: 'start' | 'end' | 'center';
    hasLabelText?: boolean;
    dropdownItemWidth?: ObjectDevices<string>;
    fixedDropdownWidth?: ObjectDevices<string | number>;
    variantSpacing: Spacing;
};
type PostPurchaseProductVariantsProps = BasePropsWrap<PostPurchaseProductVariantSettingProps, PostPurchaseProductVariantStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type VariantPreset$1 = {
    optionType: string;
    optionName: string;
    hide?: boolean;
    presets: {
        [key in VariantTypeof$1]?: VariantBaseSetting$1;
    };
};

declare const PostPurchaseProductVariants: React.FC<PostPurchaseProductVariantsProps>;

type PostPurchaseProductQuantitySettingProps = {
    title?: string;
    defaultQtyValue?: number;
};
type PostPurchaseProductQuantityStyleProps = {
    fullWidth?: ObjectDevices<boolean>;
    inputWidth?: ObjectDevices<string | number>;
    align?: 'start' | 'end' | 'center';
};
type PostPurchaseProductQuantityProps = BaseProps<PostPurchaseProductQuantitySettingProps, PostPurchaseProductQuantityStyleProps>;

type PostPurchaseProductPriceBreakdownSettingProps = {
    subTotalLabel?: string;
    discountLabel?: string;
    shippingLabel?: string;
    taxesLabel?: string;
    totalLabel?: string;
    discountAndShippingFee?: boolean;
    contentShow?: string;
    contentHide?: string;
    isShowRecurringTotalLabel?: boolean;
};
type PostPurchaseProductPriceBreakdownStyleProps = {
    labelStyle?: PostPurchaseTypo;
    moneyStyle?: PostPurchaseTypo;
    align?: 'left' | 'right' | 'center';
    width?: ObjectDevices<string>;
    spacing?: Spacing;
    isShowPrice?: boolean;
    isShowSubTotalLabel?: boolean;
    isShowDiscountLabel?: boolean;
    isShowShippingLabel?: boolean;
    isShowTaxesLabel?: boolean;
    isShowTotalLabel?: boolean;
    direction?: 'ltr' | 'rtl';
};
type PostPurchaseProductPriceBreakdownProps = BasePropsWrap<PostPurchaseProductPriceBreakdownSettingProps, PostPurchaseProductPriceBreakdownStyleProps> & {
    advanced?: AdvancedType;
    children?: ReactNode;
};

type FeatureImageStyles$2 = {
    ftLayout?: ObjectDevices<ObjectFit$2>;
    ftShape?: ObjectDevices<SizeSettingGlobal>;
    ftCorner?: CornerRadius;
};
type OriginalFeatureImageSetting$1 = {
    ftClickOpenLightBox?: ObjectDevices<'none' | 'popup' | 'product-link'>;
    ftClickOpenNewTab?: boolean;
    hoverEffect?: 'zoom' | 'other' | 'none';
    zoom?: number;
    zoomType?: 'default' | 'glasses';
    otherImage?: number;
    preload?: boolean;
    ftSlidesToShow?: ObjectDevices<number | 'auto'>;
    ftControlOverContent?: ObjectDevices<boolean>;
    ftNavigationPosition?: ObjectDevices<'inside' | 'outside' | 'none'>;
    ftArrow?: ObjectDevices<boolean>;
    ftLoop?: ObjectDevices<boolean>;
    ftAnimationSpeed?: number;
    ftAnimationMode?: CarouselAnimationValue$1;
    ftPauseOnHover?: boolean;
    ftArrowIcon?: string;
    ftArrowIconSize?: ObjectDevices<number>;
    ftArrowIconColor?: ColorValueType;
    ftDragToScroll?: boolean;
    ftArrowNavColor?: string;
    ftArrowNavSize?: SizeSettingGlobal;
    ftArrowNavBorder?: Border;
    ftArrowNavRadius?: CornerRadius;
    ftArrowNavShadow?: ShadowProps;
    ftDotColor?: ObjectDevices<ColorValueType>;
    ftDotActiveColor?: ObjectDevices<ColorValueType>;
    ftDotStyle?: ObjectDevices<DotStyle$1>;
    ftDotSize?: ObjectDevices<number>;
    ftDotGapToCarousel?: ObjectDevices<number>;
};
type FeatureImageSetting$2 = OriginalFeatureImageSetting$1 & GalleryStyles$2;
type SelectDisplaySetting$1 = {
    typeDisplay?: 'all-images' | 'select-manual';
    preDisplay?: '1st-available-variant' | '1st-images' | '1st-video' | '1st-3d-mode';
};
type GalleryStyles$2 = {
    layout?: ObjectDevices<ObjectFit$2>;
    shape?: ObjectDevices<SizeSettingGlobal>;
    shapeForBottom?: ObjectDevices<SizeSettingGlobal>;
    shapeForFtOnly?: ObjectDevices<SizeSettingGlobal>;
    shapeFor2Col?: ObjectDevices<SizeSettingGlobal>;
    shapeFor1Col?: ObjectDevices<SizeSettingGlobal>;
    shapeForInsideBottom?: ObjectDevices<SizeSettingGlobal>;
    shapeForInside?: ObjectDevices<SizeSettingGlobal>;
    corner?: CornerRadius;
    itemSpacing?: ObjectDevices<string | number>;
    align?: ObjectDevices<Property.AlignItems>;
    verticalLayout?: ObjectDevices<boolean>;
    verticalLayoutRow?: ObjectDevices<boolean>;
};
type GallerySetting$2 = {
    clickOpenLightBox?: ObjectDevices<boolean>;
    type?: ObjectDevices<string>;
    galleryHoverEffect?: 'zoom' | 'none';
    galleryZoom?: number;
    galleryZoomType?: 'default' | 'glasses';
    preload?: boolean;
    slidesToShow?: ObjectDevices<number | 'auto'>;
    navigationPosition?: ObjectDevices<'inside' | 'outside' | 'none'>;
    arrow?: ObjectDevices<boolean>;
    loop?: ObjectDevices<boolean>;
    speed?: number;
    pauseOnHover?: boolean;
    arrowIcon?: string;
    arrowIconSize?: ObjectDevices<number>;
    arrowIconColor?: ColorValueType;
    dragToScroll?: boolean;
    arrowNavColor?: string;
    arrowNavSize?: SizeSettingGlobal;
    arrowNavBorder?: Border;
    arrowNavRadius?: CornerRadius;
    arrowNavShadow?: ShadowProps;
    borderActive?: Border;
};
type ProductImageOriginalSettingProps$1 = {
    qualityType?: ObjectDevices<QualityType$1>;
    qualityPercent?: ObjectDevices<number>;
    displayByVariant?: boolean;
    variantSelect?: string;
    filterByVariant?: string;
};
type ProductImagesSetting$2 = ProductImageOriginalSettingProps$1 & GallerySetting$2 & FeatureImageSetting$2 & SelectDisplaySetting$1;
type ProductImagesStyles$2 = GalleryStyles$2 & FeatureImageStyles$2 & {
    spacing?: ObjectDevices<string | number>;
    position?: ObjectDevices<ProductImagesLayout$2>;
    ratioLayout?: ObjectDevices<number[]>;
    ratioLayoutRight?: ObjectDevices<number[]>;
    align?: ObjectDevices<Property.AlignItems>;
};
type ProductImagesProps$2 = BasePropsWrap<ProductImagesSetting$2, ProductImagesStyles$2> & {
    className?: string;
    children?: React.ReactNode;
    dotSize?: Partial<Record<NameDevices, number>>;
    dotGapToCarousel?: Partial<Record<NameDevices, number | string>>;
};
type QualityType$1 = 'finest' | 'high' | 'medium' | 'custom';
type ProductImagesLayout$2 = 'bottom-left' | 'bottom-center' | 'left' | 'right' | 'only-feature' | 'one-col' | 'two-col' | 'inside-bottom' | 'inside-left' | 'inside-right';

type FeatureImagStyle = {
    ftAspectRatio?: string;
    ftWidth?: ObjectDevices<string>;
    ftObjectFit?: ObjectFit;
    ftNavigation?: 'none' | 'display';
    ftSpacing?: Spacing;
};
type ImageListSetting = {
    displayType: 'slider' | 'grid';
};
type ImageListStyle = {
    ilAspectRatio?: string;
    ilObjectFit?: ObjectFit;
    ilBorder: 'none' | 'display';
    ilSpacing: Spacing;
    ilNavigation: 'none' | 'display';
    ilItemPerSlide: number;
    ilNumberPerRow: number;
};
type ProductImageLayoutSettings = {
    layoutType?: ProductImagesLayout$1;
    spacingHoz?: string;
    spacingVertical?: Spacing;
    ratioLayoutLeft?: number[];
    ratioLayoutRight?: number[];
    ftEnabled?: boolean;
    ilEnabled?: boolean;
};
type ProductImagesLayout$1 = 'bottom-center' | 'left' | 'right' | 'only-feature' | 'one-col' | 'two-col';
type ProductImagesSettingProps = ImageListSetting & ProductImageLayoutSettings;
type AlignSetting = {
    align?: 'left' | 'right' | 'center';
};
type ProductImagesStyleProps = ImageListStyle & FeatureImagStyle & AlignSetting;
type PostPurchaseProductImagesProps = BasePropsWrap<ProductImagesSettingProps, ProductImagesStyleProps> & {
    className?: string;
    children?: React.ReactNode;
};

declare const postPurchaseSpacing: Record<string, string>;

type ProductSubscriptionSettingProps = {
    sellingType?: 'one-time' | 'subscription';
    sellingLabel?: string;
    sellingTitleOneTime?: string;
    sellingStyle?: 'dropdown' | 'radio' | 'image';
    sellingTitle?: string;
    subscriptionLabel?: string;
    enableSubscriptionDetail?: boolean;
    sellingPlans?: {
        [key: string]: {
            [key: string]: {
                appSource?: string;
                group?: string;
                defaultOption?: string;
            };
        };
    };
};
type ProductSubscriptionStyleProps = {
    sellingTitleDirection?: 'ltr' | 'rtl';
    sellingTitleTypo?: PostPurchaseTypo;
    sellingTitleAlign?: AlignItemProp;
    sellingTitleOneTimeDirection?: 'ltr' | 'rtl';
    sellingTitleOneTimeTypo?: PostPurchaseTypo;
    sellingTitleOneTimeAlign?: AlignItemProp;
    subscriptionDetailDirection?: 'ltr' | 'rtl';
    subscriptionDetailTypo?: PostPurchaseTypo;
    subscriptionDetailAlign?: AlignItemProp;
    sellingPlanItemGap?: keyof typeof postPurchaseSpacing;
    width?: string;
    align?: AlignItemProp;
    sellingPlanId?: string;
};
type PostPurchaseProductSubscriptionProps = BasePropsWrap<ProductSubscriptionSettingProps, ProductSubscriptionStyleProps> & {
    advanced?: any;
    children?: ReactNode;
};

type PostPurchaseProductTitleSettingProps = PostPurchaseTextSettingProps & {
    linkProduct?: boolean;
};
type PostPurchaseProductTitleStyleProps = PostPurchaseTextStyleProps;
type PostPurchaseProductTitleProps = BaseProps<PostPurchaseProductTitleSettingProps, PostPurchaseProductTitleStyleProps>;

declare const PostPurchaseProductTitle: React.FC<PostPurchaseProductTitleProps>;

type PostPurchaseProductDescriptionProps = BaseProps<PostPurchaseTextSettingProps, PostPurchaseTextStyleProps>;

declare const PostPurchaseProductDescription: React.FC<PostPurchaseProductDescriptionProps>;

type PostPurchaseProductPriceSettingProps = {
    moneyWithCurrentFormat?: boolean;
    discountAndShippingFee?: boolean;
    priceType?: 'offer' | 'compare';
    source?: 'price' | 'compare-price';
};
type OriginalStyleProps$4 = {
    lineThrough?: boolean;
};
type PostPurchaseProductPriceStyleProps = OriginalStyleProps$4 & PostPurchaseTextSettingProps & PostPurchaseTextStyleProps;
type PostPurchaseProductPriceProps = BasePropsWrap<PostPurchaseProductPriceSettingProps, PostPurchaseProductPriceStyleProps> & {
    advanced?: any;
    children?: ReactNode;
};

declare const PostPurchaseProductPrice: React.FC<PostPurchaseProductPriceProps>;

declare const PostPurchaseAcceptButton: (props: PostPurchaseButtonProps) => React.JSX.Element;

declare const PostPurchaseProductQuantity: React.FC<PostPurchaseProductQuantityProps>;

declare const PostPurchaseProductPriceBreakdown: React.FC<PostPurchaseProductPriceBreakdownProps>;

type ProductDiscountTagSettingProps = {
    message?: string;
    discountAndShippingFee?: boolean;
};
type ProductDiscountTagStyleProps = {
    typo?: PostPurchaseTypo;
    direction?: 'ltr' | 'rtl';
    width?: ObjectDevices<string>;
    textAlign?: AlignItemProp;
    align?: AlignItemProp;
};
type PostPurchaseProductDiscountTagProps = BasePropsWrap<ProductDiscountTagSettingProps, ProductDiscountTagStyleProps> & {
    advanced?: AdvancedType;
    children?: ReactNode;
};

declare const PostPurchaseProductDiscountTag: React.FC<PostPurchaseProductDiscountTagProps>;

declare const ProductSubscription: React.FC<PostPurchaseProductSubscriptionProps>;

declare const PostPurchaseProductImages: (props: PostPurchaseProductImagesProps) => React.JSX.Element;

declare const postPurchaseProduct1Col: {
    id: string;
    name: string;
    icon: {
        desktop: string;
    };
    components: {
        tag: string;
        settings: {
            layout: {
                desktop: {
                    cols: number[];
                    display: string;
                };
            };
        };
        childrens: ({
            tag: string;
            childrens: {
                tag: string;
                styles: {
                    position: {
                        desktop: string;
                        mobile: string;
                    };
                };
                settings: {
                    ftDragToScroll: boolean;
                    ftNavigationPosition: {
                        desktop: string;
                    };
                };
                advanced: {
                    advanced: {
                        blockPadding: string;
                    };
                };
            }[];
        } | {
            tag: string;
            childrens: ({
                tag: string;
                advanced: {
                    advanced: {
                        blockPadding: string;
                    };
                };
                settings?: undefined;
                styles?: undefined;
                childrens?: undefined;
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display: string;
                        };
                        mobile?: undefined;
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                advanced: {
                    advanced: {
                        blockPadding: string;
                    };
                };
                childrens: {
                    tag: string;
                    childrens: {
                        tag: string;
                        styles: {
                            priceType: string;
                        };
                    }[];
                }[];
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display?: undefined;
                        };
                        mobile: {
                            cols: number[];
                        };
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                childrens: ({
                    tag: string;
                    childrens: {
                        tag: string;
                        advanced: {
                            advanced: {
                                blockPadding: string;
                            };
                        };
                        settings: {
                            text: string;
                            buttonType: string;
                        };
                        styles: {
                            fullWidth: {
                                desktop: boolean;
                            };
                        };
                    }[];
                } | {
                    tag: string;
                    childrens: {
                        tag: string;
                        advanced: {
                            blockPadding: string;
                        };
                        settings: {
                            text: string;
                            buttonType: string;
                        };
                        styles: {
                            fullWidth: {
                                desktop: boolean;
                            };
                        };
                    }[];
                })[];
                advanced?: undefined;
            })[];
        })[];
    }[];
};

declare const postPurchaseProduct2Col: {
    id: string;
    name: string;
    icon: {
        desktop: string;
    };
    components: {
        tag: string;
        settings: {
            layout: {
                desktop: {
                    cols: number[];
                    display: string;
                };
                mobile: {
                    cols: number[];
                };
            };
        };
        styles: {
            columnGap: {
                desktop: string;
            };
        };
        childrens: ({
            tag: string;
            childrens: {
                tag: string;
                styles: {
                    position: {
                        desktop: string;
                        mobile: string;
                    };
                };
                settings: {
                    ftDragToScroll: boolean;
                    ftNavigationPosition: {
                        desktop: string;
                    };
                };
                advanced: {
                    blockPadding: string;
                };
            }[];
        } | {
            tag: string;
            childrens: ({
                tag: string;
                advanced: {
                    blockPadding: string;
                    advanced?: undefined;
                };
                settings?: undefined;
                styles?: undefined;
                childrens?: undefined;
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display: string;
                        };
                        mobile?: undefined;
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                advanced: {
                    advanced: {
                        blockPadding: string;
                    };
                    blockPadding?: undefined;
                };
                childrens: {
                    tag: string;
                    childrens: {
                        tag: string;
                        styles: {
                            priceType: string;
                        };
                    }[];
                }[];
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display?: undefined;
                        };
                        mobile: {
                            cols: number[];
                        };
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                childrens: {
                    tag: string;
                    childrens: {
                        tag: string;
                        advanced: {
                            blockPadding: string;
                        };
                        settings: {
                            text: string;
                            buttonType: string;
                        };
                        styles: {
                            fullWidth: {
                                desktop: boolean;
                            };
                        };
                    }[];
                }[];
                advanced?: undefined;
            })[];
        })[];
    }[];
};

declare const postPurchaseProductDefault: {
    id: string;
    name: string;
    icon: {
        desktop: string;
    };
    components: {
        tag: string;
        settings: {
            layout: {
                desktop: {
                    cols: number[];
                    display: string;
                };
                mobile: {
                    cols: number[];
                };
            };
        };
        styles: {
            columnGap: {
                desktop: string;
            };
        };
        childrens: ({
            tag: string;
            childrens: {
                tag: string;
                styles: {
                    position: {
                        desktop: string;
                        mobile: string;
                    };
                };
                settings: {
                    ftDragToScroll: boolean;
                    ftNavigationPosition: {
                        desktop: string;
                    };
                };
                advanced: {
                    blockPadding: string;
                };
            }[];
        } | {
            tag: string;
            childrens: ({
                tag: string;
                advanced: {
                    blockPadding: string;
                };
                settings?: undefined;
                styles?: undefined;
                childrens?: undefined;
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display: string;
                        };
                        mobile?: undefined;
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                advanced: {
                    blockPadding: string;
                };
                childrens: ({
                    tag: string;
                    childrens: {
                        tag: string;
                        styles: {
                            priceType: string;
                        };
                    }[];
                } | {
                    tag: string;
                    childrens: {
                        tag: string;
                        styles: {
                            priceType: string;
                            color: {
                                normal: string;
                            };
                        };
                    }[];
                })[];
            } | {
                tag: string;
                settings: {
                    layout: {
                        desktop: {
                            cols: number[];
                            display?: undefined;
                        };
                        mobile: {
                            cols: number[];
                        };
                    };
                    verticalAlign: {
                        desktop: string;
                    };
                };
                styles: {
                    columnGap: {
                        desktop: string;
                    };
                };
                childrens: {
                    tag: string;
                    childrens: {
                        tag: string;
                        advanced: {
                            blockPadding: string;
                        };
                        settings: {
                            text: string;
                            buttonType: string;
                        };
                        styles: {
                            fullWidth: {
                                desktop: boolean;
                            };
                        };
                    }[];
                }[];
                advanced?: undefined;
            })[];
        })[];
    }[];
};

declare const postPurchaseProductSetting: {
    PostPurchaseProductTitle: _gem_sdk_core.ComponentSetting<PostPurchaseProductTitleProps>;
    PostPurchaseProductDescription: _gem_sdk_core.ComponentSetting<PostPurchaseProductDescriptionProps>;
    PostPurchaseProductPrice: _gem_sdk_core.ComponentSetting<PostPurchaseProductPriceProps>;
    PostPurchaseProductVariants: _gem_sdk_core.ComponentSetting<PostPurchaseProductVariantsProps>;
    PostPurchaseAcceptButton: _gem_sdk_core.ComponentSetting<PostPurchaseButtonProps>;
    PostPurchaseProductQuantity: _gem_sdk_core.ComponentSetting<PostPurchaseProductQuantityProps>;
    PostPurchaseProductPriceBreakdown: _gem_sdk_core.ComponentSetting<PostPurchaseProductPriceBreakdownProps>;
    PostPurchaseProductOffer: _gem_sdk_core.ComponentSetting<PostPurchaseProductOfferProps>;
    PostPurchaseProductDiscountTag: _gem_sdk_core.ComponentSetting<PostPurchaseProductDiscountTagProps>;
    PostPurchaseProductImages: _gem_sdk_core.ComponentSetting<PostPurchaseProductImagesProps>;
    PostPurchaseProductSubscription: _gem_sdk_core.ComponentSetting<PostPurchaseProductSubscriptionProps>;
};

type PostPurchaseBuyerConsentSettingProps = {
    description?: string;
    translate?: string;
    selected?: boolean;
    policyLink?: string;
    policyLabel?: string;
    align?: AlignItemProp;
};
type PostPurchaseBuyerConsentStyleProps = {
    globalSize?: ObjectDevices<SizeSettingGlobal>;
    horizontalSpacing?: Property.Padding;
    direction?: 'ltr' | 'rtl';
    width?: string;
    textAlign?: AlignItemProp;
    typo?: PostPurchaseTypo;
};
type PostPurchaseBuyerConsentProps = BasePropsWrap<PostPurchaseBuyerConsentSettingProps, PostPurchaseBuyerConsentStyleProps> & {
    children: React.ReactNode;
};

declare const BuyerConsent: React.FC<PostPurchaseBuyerConsentProps>;

declare const postPurchaseBuyerConsentSetting: {
    PostPurchaseBuyerConsent: _gem_sdk_core.ComponentSetting<PostPurchaseBuyerConsentProps>;
};

type FeatureImageStyles$1 = {
    ftLayout?: ObjectDevices<ObjectFit$2>;
    ftShape?: ObjectDevices<SizeSettingGlobal>;
    ftCorner?: CornerRadius;
};
type OriginalFeatureImageSetting = {
    ftClickOpenLightBox?: ObjectDevices<'none' | 'popup' | 'product-link'>;
    ftClickOpenNewTab?: boolean;
    hoverEffect?: 'zoom' | 'other' | 'none';
    zoom?: number;
    zoomType?: 'default' | 'glasses';
    otherImage?: number;
    preload?: boolean;
    ftSlidesToShow?: ObjectDevices<number | 'auto'>;
    ftControlOverContent?: ObjectDevices<boolean>;
    ftNavigationPosition?: ObjectDevices<'inside' | 'outside' | 'none'>;
    ftArrow?: ObjectDevices<boolean>;
    ftLoop?: ObjectDevices<boolean>;
    ftAnimationSpeed?: number;
    ftAnimationMode?: CarouselAnimationValue;
    ftPauseOnHover?: boolean;
    ftArrowIcon?: string;
    ftArrowIconSize?: ObjectDevices<number>;
    ftArrowIconColor?: ColorValueType;
    ftDragToScroll?: boolean;
    ftArrowNavColor?: string;
    ftArrowNavBorder?: Border;
    ftArrowNavRadius?: CornerRadius;
    ftArrowNavShadow?: ShadowProps;
    ftDotColor?: ObjectDevices<ColorValueType>;
    ftDotActiveColor?: ObjectDevices<ColorValueType>;
    ftDotStyle?: ObjectDevices<DotStyle>;
    ftDotSize?: ObjectDevices<number>;
    ftDotGapToCarousel?: ObjectDevices<number>;
};
type FeatureImageSetting$1 = OriginalFeatureImageSetting & GalleryStyles$1;
type SelectDisplaySetting = {
    typeDisplay?: 'all-images' | 'select-manual';
    preDisplay?: '1st-available-variant' | '1st-images' | '1st-video' | '1st-3d-mode';
};
type GalleryStyles$1 = {
    layout?: ObjectDevices<ObjectFit$2>;
    shape?: ObjectDevices<SizeSettingGlobal>;
    shapeForBottom?: ObjectDevices<SizeSettingGlobal>;
    shapeForFtOnly?: ObjectDevices<SizeSettingGlobal>;
    shapeFor2Col?: ObjectDevices<SizeSettingGlobal>;
    shapeFor1Col?: ObjectDevices<SizeSettingGlobal>;
    shapeForInsideBottom?: ObjectDevices<SizeSettingGlobal>;
    shapeForInside?: ObjectDevices<SizeSettingGlobal>;
    corner?: CornerRadius;
    itemSpacing?: ObjectDevices<string | number>;
    align?: ObjectDevices<Property.AlignItems>;
    verticalLayout?: ObjectDevices<boolean>;
    verticalLayoutRow?: ObjectDevices<boolean>;
};
type GallerySetting$1 = {
    clickOpenLightBox?: ObjectDevices<boolean>;
    type?: ObjectDevices<string>;
    galleryHoverEffect?: 'zoom' | 'none';
    galleryZoom?: number;
    galleryZoomType?: 'default' | 'glasses';
    preload?: boolean;
    slidesToShow?: ObjectDevices<number | 'auto'>;
    navigationPosition?: ObjectDevices<'inside' | 'outside' | 'none'>;
    arrow?: ObjectDevices<boolean>;
    loop?: ObjectDevices<boolean>;
    speed?: number;
    pauseOnHover?: boolean;
    arrowIcon?: string;
    arrowIconSize?: ObjectDevices<number>;
    arrowIconColor?: ColorValueType;
    dragToScroll?: boolean;
    arrowNavColor?: string;
    arrowNavBorder?: Border;
    arrowNavRadius?: CornerRadius;
    arrowNavShadow?: ShadowProps;
    borderActive?: Border;
};
type ProductImageOriginalSettingProps = {
    qualityType?: ObjectDevices<QualityType>;
    qualityPercent?: ObjectDevices<number>;
    displayByVariant?: boolean;
    variantSelect?: string;
};
type ProductImagesSetting$1 = ProductImageOriginalSettingProps & GallerySetting$1 & FeatureImageSetting$1 & SelectDisplaySetting;
type ProductImagesStyles$1 = GalleryStyles$1 & FeatureImageStyles$1 & {
    spacing?: ObjectDevices<string | number>;
    position?: ObjectDevices<ProductImagesLayout>;
    ratioLayout?: ObjectDevices<number[]>;
    ratioLayoutRight?: ObjectDevices<number[]>;
    align?: ObjectDevices<Property.AlignItems>;
};
type ProductImagesProps$1 = BasePropsWrap<ProductImagesSetting$1, ProductImagesStyles$1> & {
    className?: string;
    children?: React.ReactNode;
    dotSize?: Partial<Record<NameDevices, number>>;
    dotGapToCarousel?: Partial<Record<NameDevices, number | string>>;
};
type QualityType = 'finest' | 'high' | 'medium' | 'custom';
type ProductImagesLayout = 'bottom-left' | 'bottom-center' | 'left' | 'right' | 'only-feature' | 'one-col' | 'two-col' | 'inside-bottom' | 'inside-left' | 'inside-right';

type OriginalSettingProps$5 = {
    linkProduct?: boolean;
};
type ProductTitleSettingProps = OriginalSettingProps$5 & TextSettingProps;
type ProductTitleStyleProps = TextStyleProps;
type ProductTitleProps = BaseProps<ProductTitleSettingProps, ProductTitleStyleProps>;

type ProductDescriptionSettingProps = {
    htmlTag?: 'plaintext' | 'html';
    hasLineClamp?: ObjectDevices<boolean>;
    lineClamp?: ObjectDevices<number>;
    viewMoreText?: string;
    viewLessText?: string;
    enableViewMoreIcon?: boolean;
    showMoreColor?: ColorValueType;
    color?: ColorValueType;
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    textAlign?: ObjectDevices<AlignProp>;
    hasTextShadow?: boolean;
    textShadow?: ShadowProps;
    hasBoxShadow?: boolean;
    boxShadow?: ShadowProps;
    transform?: TransformProp;
};
type ProductDescriptionProps = BaseProps<ProductDescriptionSettingProps> & {
    pageContext?: PageContext;
};

type bundleItem = {
    quantity: number;
    discountValue: string;
    discountType: 'percentage' | 'fixed_amount' | 'no_discount';
};

type ProductPriceSettingProps = {
    moneyWithCurrentFormat?: boolean;
    isProductBundle?: boolean;
    boxShadowPrice?: ShadowProps;
    hasBoxShadowPrice?: boolean;
    opacityPrice?: number;
    priceType?: 'regular' | 'compare';
};
type ProductPriceStyleProps = {
    disableHoverColor?: boolean;
    lineThrough?: boolean;
    thickness?: number | string;
    lineColor?: ColorValueType;
} & TextStyleProps & TextSettingProps;
type ProductPriceProps = BasePropsWrap<ProductPriceSettingProps, ProductPriceStyleProps> & {
    advanced?: any;
    children?: ReactNode;
    classNames?: string;
    'bundle-item'?: bundleItem;
    pageContext?: PageContext;
};

type OriginalSettingProps$4 = {
    label?: string;
    translate?: string;
    outOfStockLabel?: string;
    unavailableLabel?: string;
    labelUnavailableTranslate?: string;
    labelOutOfStockTranslate?: string;
    actionEffect?: 'open-cart-drawer' | 'buy-now' | 'continue-shopping' | 'go-to-url';
    customURL?: {
        link?: string;
        target?: string;
    };
    successMessage?: string;
    errorMessage?: string;
    variantSelectionRequiredMessage?: string;
    errorType?: string;
    shouldClearSpace?: boolean;
    messageLayout?: 'inline' | 'popup';
    buttonLayout?: ButtonLayout;
    priceLayout?: string;
    priceTypo?: TypographySettingV2;
    compareAtPriceTypo?: TypographySettingV2;
    shadowPrice?: StateProp<ShadowProps>;
    hasShadowPrice?: StateProp<boolean>;
    iconSize?: ObjectDevices<number>;
    enableMessage?: boolean;
    enableSuccessMessage?: boolean;
    enableErrorMessage?: boolean;
    opacityPrice?: number;
    separator?: Separator;
};
type ProductButtonSettingProps = OriginalSettingProps$4 & Pick<ButtonSettingProps, 'iconAlign' | 'iconSvg' | 'iconVisible' | 'enableHoverEffect'>;
type OriginalStyleProps$3 = {
    successTypo?: NonNullable<TextProps['styles']>['typo'];
    successColor?: ColorValueType;
    priceColorHover?: ObjectDevices<StateProp<ColorValueType>>;
    compareAtPriceColorHover?: ObjectDevices<StateProp<ColorValueType>>;
    errorTypo?: NonNullable<TextProps['styles']>['typo'];
    errorColor?: ColorValueType;
    isCustomOutOfStock?: boolean;
    oosBackground?: ColorValueType;
    oosTextColor?: ColorValueType;
    oosBorder?: StateProp<Border>;
    oosEnableShadow?: boolean;
    oosShadow?: ShadowProps;
    oosRounded?: CornerRadius;
    oosIconColor?: ColorValueType;
    oosBackgroundV2?: StateProp<ColorValueType>;
    oosTextColorV2?: StateProp<ColorValueType>;
    oosBorderV2?: StateProp<Border>;
    oosShadowV2?: StateProp<ShadowProps>;
    oosRoundedV2?: StateProp<CornerRadius>;
    enableIcon?: boolean;
    enableTextStyle?: boolean;
    enablePrice?: boolean;
    enableSeparator?: boolean;
};
type ProductButtonStyleProps = OriginalStyleProps$3 & ButtonStyleProps;
type ProductButtonProps = BasePropsWrap<ProductButtonSettingProps, ProductButtonStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
    children?: React.ReactNode;
};
type ProductButtonPropsTranslateKeys = keyof (ProductButtonSettingProps & ProductButtonStyleProps);
type Separator = 'horizontal-line' | 'vertical-line' | 'dot';
type ButtonLayout = 'cart-only' | 'cart-icon' | 'cart-price' | 'cart-price-icon' | 'cart-full' | 'icon-only';

type ProductVariantsStyleProps = {
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number>;
    swatchAutoWidth?: ObjectDevices<boolean>;
    swatchWidth?: ObjectDevices<string | number>;
    swatchHeight?: ObjectDevices<string | number>;
    align?: ObjectDevices<AlignProp>;
    /** deprecated */
    labelTypography?: TypographySetting;
    labelTypo?: TypographySettingV2;
    labelColor?: ColorValueType;
    labelGap?: string;
    optionSpacing?: string;
    swatchSpacing?: string;
    marginBottom?: ObjectDevices<Property.MarginBottom>;
    /** deprecated */
    optionTransform?: string;
    /** deprecated */
    optionTypography?: TypographySetting;
    optionTypo?: TypographySettingV2;
    optionBgColor?: StateProp<ColorValueType>;
    optionTextColor?: StateProp<ColorValueType>;
    optionBorder?: StateProp<Border>;
    optionRounded?: StateProp<CornerRadius>;
    optionHasShadow?: StateProp<boolean>;
    optionShadow?: StateProp<ShadowProps>;
    hasLabelText?: boolean;
    dropdownItemWidth?: ObjectDevices<string>;
    fixedDropdownWidth?: ObjectDevices<string | number>;
    swatchItemWidth?: ObjectDevices<string>;
    combineHeight?: string | number;
    combineFullWidth?: ObjectDevices<boolean>;
    combineWidth?: ObjectDevices<string | number>;
};
type ProductVariantsSettingProps = {
    optionType?: 'singleOption' | 'groupOption';
    variantPresets?: VariantPreset[];
    label?: boolean;
    price?: boolean;
    showAsSwatches?: boolean;
    layout?: ObjectDevices<string>;
    column?: ObjectDevices<string | number>;
    optionAlign?: ObjectDevices<AlignProp>;
    hasPreSelected?: boolean;
    blankText?: string;
    combineHeight?: string | number;
    combineFullWidth?: ObjectDevices<boolean>;
    combineWidth?: ObjectDevices<string | number>;
    soldOutStyle?: SoldOutStyleType;
    soldOutMark?: boolean;
    hasOnlyDefaultVariant?: boolean;
};
type ProductVariantsProps = BaseProps<ProductVariantsSettingProps, ProductVariantsStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};
type VariantTypeof = 'dropdown' | 'rectangle_list' | 'image_shopify' | 'color' | 'image' | string;
type SoldOutStyleType = 'none' | 'disable' | 'line';
type VariantBaseSetting = {
    fullWidth?: Partial<Record<NameDevices, boolean>>;
    width?: Partial<Record<NameDevices, string>>;
    height?: string;
    spacing?: string;
    optionBgColor?: StateProp<ColorValueType>;
    optionTextColor?: StateProp<ColorValueType>;
    optionBorder?: StateProp<Border>;
    optionRounded?: StateProp<CornerRadius>;
    optionHasShadow?: StateProp<boolean>;
    optionShadow?: StateProp<ShadowProps>;
};
type VariantPreset = {
    optionType: string;
    optionName: string;
    hide?: boolean;
    presets: Record<VariantTypeof, VariantBaseSetting>;
    isEdited?: boolean;
};

type ProductPropertiesSettingProps = {
    name?: string;
    block?: boolean;
    placeholder?: string;
    type?: 'text' | 'textarea' | 'email' | 'checkbox' | 'radio' | 'dropdown' | 'hidden';
    label?: string;
    valueHidden?: string;
    required?: boolean;
    numberOnly?: boolean;
    minChar?: number;
    maxChar?: number;
    minNumber?: number;
    maxNumber?: number;
    dateRange?: boolean;
    childItem?: string[];
    requiredMessage?: string;
    invalidEmailMessage?: string;
    invalidNumberMessage?: string;
    invalidLengthMessage?: string;
};
type ProductPropertiesStyleProps = {
    labelTypography?: TypographySetting;
    labelTypo?: TypographySettingV2;
    labelBgColor?: ColorValueType;
    labelTextColor?: ColorValueType;
    labelTransform?: string;
    valueTypography?: TypographySetting;
    valueTypo?: TypographySettingV2;
    valueBgColor?: ObjectDevices<StateProp<ColorValueType>>;
    valueTextColor?: StateProp<ColorValueType>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string | number | undefined>;
    height?: ObjectDevices<string | number | undefined>;
    borderInput?: StateProp<Border>;
    hasShadowInput?: StateProp<boolean>;
    shadowInput?: StateProp<ShadowProps>;
    borderRadius?: StateProp<CornerRadius>;
    spacing?: string;
    textAlign?: ObjectDevices<AlignProp>;
    isDisplayLabel?: boolean;
};
type ProductPropertiesProps = BaseProps<ProductPropertiesSettingProps, ProductPropertiesStyleProps>;

type ProductTagSettingProps = {
    customContent?: {
        prefix?: string;
        suffix?: string;
        unit?: 'percentage' | 'price';
    };
    translate?: string;
    isSaleLabel?: boolean;
    saleLabel?: string;
    isSoldOutLabel?: boolean;
    soldOutLabel?: string;
    isNewLabel?: boolean;
    newLabel?: string;
    moneyWithCurrentFormat?: boolean;
} & TextSettingProps;
type OriginalStyleProps$2 = {
    textAlign?: ObjectDevices<AlignProp>;
    backgroundColor?: ColorValueType;
    textColor?: ColorValueType;
    roundedTag?: CornerRadius;
    borderTag?: Border;
    backgroundColorSale?: ColorValueType;
    textColorSale?: ColorValueType;
    roundedSale?: CornerRadius;
    borderSale?: Border;
    backgroundColorSoldOut?: ColorValueType;
    textColorSoldOut?: ColorValueType;
    roundedSoldOut?: CornerRadius;
    borderSoldOut?: Border;
    backgroundColorNew?: ColorValueType;
    textColorNew?: ColorValueType;
    roundedNew?: CornerRadius;
    borderNew?: Border;
    tagSpacing?: SizeSetting;
    textContentAlign?: ObjectDevices<AlignProp>;
    size?: ObjectDevices<SizeSettingGlobal>;
};
type ProductTagStyleProps = OriginalStyleProps$2 & TextStyleProps;
type ProductTagSidebarSettingProps = {
    setting: Pick<ProductTagSettingProps, 'customContent' | 'translate'>;
    styles: Pick<OriginalStyleProps$2, 'size' | 'textContentAlign' | 'backgroundColor' | 'borderTag' | 'roundedTag' | 'textAlign'> & Pick<TextStyleProps, 'typo'>;
};
type ProductTagProps = BaseProps<ProductTagSettingProps, ProductTagStyleProps> & {
    'bundle-item'?: bundleItem;
};

type ProductSortedByOrderType$1 = 'TITLE_ASC' | 'TITLE_DESC' | 'CREATED_AT_ASC' | 'CREATED_AT_DESC' | 'none' | undefined;
type ProductSource$1 = 'Collection' | 'PickProduct' | 'DynamicCollection' | 'RelatedProduct';
type RelatedCondition$1 = 'collection' | 'production-type' | 'vendor' | 'tags' | 'category';
type OriginalStyleProps$1 = {
    layout?: 'grid' | 'slider';
    horizontalGutter?: ObjectDevices<string>;
    verticalGutter?: ObjectDevices<string>;
    fullWidth?: ObjectDevices<boolean>;
    adaptiveHeight?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
    backgroundColor?: ObjectDevices<ColorValueType>;
    backgroundImage?: ObjectDevices<BackgroundImageValue>;
    preloadBgImage?: boolean;
    align?: ObjectDevices<AlignProp>;
};
type ProductListStyleProps$1 = OriginalStyleProps$1 & CarouselStyleProps$1;
type OriginalSettingProps$3 = {
    productSetting?: {
        productSrc?: ProductSource$1;
        productIds?: string[];
        collectionId?: string;
        collectionHandle?: string;
        productHandles?: string[];
        numOfSelectedProducts?: number;
        relatedTag?: RelatedCondition$1[];
        relatedType?: 'related-product' | 'recommended-product';
        hasRelatedExclude?: boolean;
        relatedExclude?: string;
        relatedTagsExclude?: string;
        relatedCollectionExclude?: string;
        relatedProductId?: string;
        relatedProductHandle?: string;
    };
    randomizeOrder?: boolean;
    numberOfProducts?: number;
    col?: number;
    scrollMode?: ObjectDevices<'snap' | 'free' | 'free-snap'>;
    orderBy?: ProductSortedByOrderType$1;
    sameHeight?: boolean;
};
type ProductListSettingProps$1 = OriginalSettingProps$3 & CarouselSettingProps$1;
type ProductListProps$1 = BasePropsWrap<ProductListSettingProps$1, ProductListStyleProps$1> & {
    style?: React.CSSProperties;
    className?: string;
    children: React.ReactNode;
    pageContext?: PageContext;
    rawChildren: any;
};

type ProductSortedByOrderType = 'TITLE_ASC' | 'TITLE_DESC' | 'CREATED_AT_ASC' | 'CREATED_AT_DESC' | 'none' | undefined;
type ProductSource = 'Collection' | 'PickProduct' | 'DynamicCollection' | 'RelatedProduct';
type RelatedCondition = 'collection' | 'production-type' | 'vendor' | 'tags' | 'category';
type OriginalStyleProps = {
    layout?: 'grid' | 'slider';
    horizontalGutter?: ObjectDevices<string>;
    verticalGutter?: ObjectDevices<string>;
    fullWidth?: ObjectDevices<boolean>;
    adaptiveHeight?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
    backgroundColor?: ObjectDevices<ColorValueType>;
    backgroundImage?: ObjectDevices<BackgroundImageValue>;
    preloadBgImage?: boolean;
    align?: ObjectDevices<AlignProp>;
};
type ProductListStyleProps = OriginalStyleProps & CarouselStyleProps;
type OriginalSettingProps$2 = {
    productSetting?: {
        productSrc?: ProductSource;
        productIds?: string[];
        collectionId?: string;
        collectionHandle?: string;
        productHandles?: string[];
        numOfSelectedProducts?: number;
        relatedTag?: RelatedCondition[];
        relatedType?: 'related-product' | 'recommended-product';
        hasRelatedExclude?: boolean;
        relatedExclude?: string;
        relatedTagsExclude?: string;
        relatedCollectionExclude?: string;
        relatedProductId?: string;
        relatedProductHandle?: string;
    };
    randomizeOrder?: boolean;
    numberOfProducts?: number;
    col?: number;
    scrollMode?: ObjectDevices<'snap' | 'free' | 'free-snap'>;
    orderBy?: ProductSortedByOrderType;
    sameHeight?: boolean;
};
type ProductListSettingProps = OriginalSettingProps$2 & CarouselSettingProps;
type ProductListProps = BasePropsWrap<ProductListSettingProps, ProductListStyleProps> & {
    style?: React.CSSProperties;
    className?: string;
    children: React.ReactNode;
    pageContext?: PageContext;
    rawChildren: any;
};

type DynamicCheckoutProps = BasePropsWrap<{} & Pick<ButtonSettingProps, 'iconAlign' | 'iconSvg' | 'iconVisible'>, ButtonProps['styles'] & {}> & {
    className?: string;
    style?: React.CSSProperties;
    advanced?: any;
    setting?: any;
};
type DynamicCheckoutLiquidProps = DynamicCheckoutProps & {
    pageContext?: PageContext;
};

type FeatureImageStyles = {
    ftAspectRatio?: ObjectDevices<string>;
    ftCustomAspectRadio?: ObjectDevices<Ratio>;
    ftLayout?: ObjectDevices<ObjectFit$2>;
    ftFullWidth?: ObjectDevices<boolean>;
    ftWidth?: ObjectDevices<string>;
    ftWidthHorizontalLayout?: ObjectDevices<string>;
    ftAlign?: ObjectDevices<Property.AlignItems>;
    ftShape?: ObjectDevices<Record<string, unknown> & {
        width: string;
    }>;
};
type FeatureImageSetting = {
    featureImageVisible?: ObjectDevices<boolean>;
    clickEffect?: string;
    hoverEffect?: 'zoom' | 'other' | 'none';
    zoom?: number;
    zoomType?: 'default' | 'glasses';
    otherImage?: number;
    hasCollectionHandle?: boolean;
};
type GalleryStyles = {
    aspectRatio?: ObjectDevices<string>;
    customAspectRadio?: ObjectDevices<Ratio>;
    layout?: ObjectDevices<ObjectFit$2>;
    align?: ObjectDevices<Property.AlignItems>;
    position?: ObjectDevices<string>;
    spacing?: ObjectDevices<string | number>;
    gallerySpacing?: ObjectDevices<string | number>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    widthHorizontalLayout?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
} & GallerySliderStyles;
type GallerySliderStyles = {
    dotColor?: ObjectDevices<ColorValueType>;
    dotActiveColor?: ObjectDevices<ColorValueType>;
    verticalLayout?: ObjectDevices<boolean>;
    verticalLayoutRow?: ObjectDevices<boolean>;
};
type GallerySliderSetting = {
    slidesToShow?: ObjectDevices<number | 'auto'>;
    dot?: ObjectDevices<boolean>;
    controlOverContent?: ObjectDevices<boolean>;
    arrow?: ObjectDevices<boolean>;
    loop?: ObjectDevices<boolean>;
    speed?: number;
    pauseOnHover?: boolean;
    arrowIcon?: string;
    dragToScroll?: boolean;
};
type GallerySetting = {
    galleryVisible?: ObjectDevices<boolean>;
    showActiveStatus?: boolean;
    largeViewInPopup?: ObjectDevices<boolean>;
    type?: ObjectDevices<string>;
    numberPerRow?: ObjectDevices<number>;
} & GallerySliderSetting;
type ProductImagesSetting = GallerySetting & FeatureImageSetting;
type ProductImagesStyles = GalleryStyles & FeatureImageStyles;
type ProductImagesProps = BasePropsWrap<ProductImagesSetting, ProductImagesStyles, Pick<ImageStyleProps$1, 'layout' | 'aspectRatio' | 'roundedImg' | 'customAspectRadio' | 'opacity'>> & {
    className?: string;
    children?: React.ReactNode;
};

type OriginalSettingProps$1 = {
    linkProduct?: boolean;
    label?: string;
    url?: boolean;
    openIn?: 'current' | 'new-tab';
};
type VendorSettingProps = OriginalSettingProps$1 & TextSettingProps;
type VendorStyleProps = {
    underlineLink?: {
        hover: boolean;
        normal: boolean;
    };
} & TextStyleProps;
type VendorProps = BaseProps<VendorSettingProps, VendorStyleProps>;

type ProductSkuSettingProps = {
    label?: string;
    htmlTag?: HTMLTag;
} & TextSettingProps;
type ProductSkuStyleProps = {
    disableHoverColor?: boolean;
    underlineLink?: {
        hover: boolean;
        normal: boolean;
    };
} & TextStyleProps;
type SkuProps = BaseProps<ProductSkuSettingProps, ProductSkuStyleProps>;

type OriginalSettingProps = {
    label?: string;
    redirectNewTab?: boolean;
};
type ProductViewMoreSettingProps = OriginalSettingProps & Pick<ButtonSettingProps, 'iconAlign' | 'iconSvg' | 'iconVisible' | 'shouldClearSpace' | 'enableHoverEffect'>;
type ProductViewMoreStyleProps = ButtonStyleProps;
type ProductViewMoreProps = BasePropsWrap<ProductViewMoreSettingProps, ProductViewMoreStyleProps> & {
    children: React.ReactNode;
};

type ProductBadgeSettingProps = {
    contentType?: 'text' | 'image';
    displayContent?: string;
    displayTrigger?: TDisplayTrigger[];
    positionWithImage?: 'inside' | 'outside';
    shape?: string;
    image?: {
        alt?: string;
        src?: string;
    };
    contentBanner?: string;
};
type ProductBadgeStyleProps = {
    typo?: TypographySettingV2;
    position?: ObjectDevices<PositionType>;
    badgeColorV2?: ObjectDevices<ColorValueType>;
    textColor?: ColorValueType;
    wrapperBorder?: Border;
    hasShadow?: boolean;
    textSizeV2?: ObjectDevices<SizeSettingGlobal>;
    imageSizeV2?: ObjectDevices<SizeSettingGlobal>;
    align?: ObjectDevices<AlignProp>;
    textBadgeBorder?: ObjectDevices<Border>;
    imageBadgeBorder?: ObjectDevices<Border>;
    textBadgeCorner?: ObjectDevices<CornerRadius>;
    imageBadgeCorner?: ObjectDevices<CornerRadius>;
    textBadgeShadow?: ObjectDevices<ShadowProps>;
    imageBadgeShadow?: ObjectDevices<ShadowProps>;
};
type ProductBadgeProps = BasePropsWrap<ProductBadgeSettingProps, ProductBadgeStyleProps> & {
    isInsideProductImage?: boolean;
    navigationPosition?: ObjectDevices<'inside' | 'outside' | 'none'>;
    children?: React.ReactNode;
    imageData: {
        imageShape?: Partial<Record<NameDevices, SizeSettingGlobal>>;
        imageAlign?: Partial<Record<NameDevices, Property.AlignItems>>;
        imageLayout?: Partial<Record<NameDevices, ProductImagesLayout$2>>;
    };
    dotData: {
        dotSize?: Partial<Record<NameDevices, number>>;
        dotGapToCarousel?: Partial<Record<NameDevices, number | string>>;
        dotStyle: Partial<Record<NameDevices, DotStyle$2>> | undefined;
    };
} & {
    'bundle-item'?: bundleItem;
    pageContext: PageContext;
};
type PositionType = {
    placement: PlacementType;
    topGap?: string;
    leftGap?: string;
    rightGap?: string;
    bottomGap?: string;
};
type PlacementType = 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left';
declare enum CompareType {
    EXACT = "exact",
    ABOVE = "above",
    BELOW = "below",
    EXACT_OR_ABOVE = "exact_or_above",
    EXACT_OR_BELOW = "exact_or_below",
    BETWEEN = "between"
}
declare enum TriggerType {
    INVENTORY_STATUS = "inventory_status",
    DISCOUNT_PRICE = "discount_price",
    PRICE_RANGE = "price_range",
    PRODUCT_TAGS = "product_tags",
    CREATION_DATE = "creation_date"
}
declare enum InventoryStatus {
    IN_STOCK = "in_stock",
    OUT_OF_STOCK = "out_of_stock"
}
declare enum CreationDateType {
    DURATION = "duration",
    EXACT_DATE = "exact_date",
    BETWEEN_DATES = "between_dates"
}
declare enum DiscountType {
    PERCENT = "percent",
    FIXED = "fixed"
}
type InventoryStatusTrigger = {
    triggerEvent: TriggerType.INVENTORY_STATUS;
    type: InventoryStatus;
    quantityType: CompareType;
    from: string;
    to?: string;
    priority: number;
    conditionType?: CompareType;
};
type DiscountPriceTrigger = {
    triggerEvent: TriggerType.DISCOUNT_PRICE;
    type: CompareType;
    amount?: string;
    from?: string;
    to?: string;
    priority: number;
    conditionType?: CompareType;
    discountType?: DiscountType;
};
type PriceRangeTrigger = {
    triggerEvent: TriggerType.PRICE_RANGE;
    from: string;
    to: string;
    priority: number;
    conditionType?: CompareType;
};
type CreationDateTrigger = {
    triggerEvent: TriggerType.CREATION_DATE;
    type: CreationDateType;
    days: string;
    from: string;
    to: string;
    priority: number;
    conditionType?: CompareType;
};
type ProductTagTrigger = {
    triggerEvent: TriggerType.PRODUCT_TAGS;
    searchTag: string[];
    priority: number;
    conditionType?: CompareType;
};
type TDisplayTrigger = InventoryStatusTrigger | DiscountPriceTrigger | PriceRangeTrigger | ProductTagTrigger | CreationDateTrigger;

type FileUploadSettingProps = {
    textContent?: string;
    fileUploadLayout?: string;
    arrangeContent?: string;
    positionVertical?: string;
    positionHorizontal?: string;
    numberOfFiles?: 'single' | 'multiple';
    isShowPreviewImage?: boolean;
    isRequired?: boolean;
    iconSvg?: string;
    iconAlignVertical?: string;
    iconAlignHorizontal?: string;
    iconVisible?: boolean;
    iconSize?: ObjectDevices<number>;
    size?: ObjectDevices<SizeSettingGlobal>;
    contentWidth?: ObjectDevices<string>;
    paddingSize?: ObjectDevices<SizeSettingGlobal>;
};
type FileUploadStyleProps = {
    typo?: TypographySettingV2;
    borderBtn?: StateProp<Border>;
    hasBoxShadowBtn?: StateProp<boolean>;
    boxShadowBtn?: StateProp<ShadowProps>;
    backgroundColor?: StateProp<ColorValueType>;
    textColor?: StateProp<ColorValueType>;
    roundedBtn?: StateProp<CornerRadius>;
    spacing?: ObjectDevices<string>;
    align?: ObjectDevices<string>;
    textAlign?: ObjectDevices<AlignProp>;
    enableHoverEffect?: boolean;
};
type FileUploadProps = BasePropsWrap<FileUploadSettingProps, FileUploadStyleProps> & {
    pageContext?: PageContext;
};

type ProductBundleDiscountSettingProps = {
    applyToInBetweenQuantities?: boolean;
    enableDisplayCondition?: boolean;
    childItem?: string[];
    hideNoDiscountItem?: boolean;
    hasPreSelectItem?: boolean;
    selectItemDefault?: number;
    layout?: 'vertical-layout' | 'horizontal-layout';
    enableIcon?: boolean;
    iconPosition?: string;
    iconHorizontalPosition?: string;
    iconSize?: ObjectDevices<number>;
    iconSpacing?: Property.Padding;
    bundleItems?: bundleItem[];
    useProductCompareAtPrice?: boolean;
    iconItemColor?: ColorValueType;
    enableHoverEffect?: boolean;
};
type ProductBundleDiscountStyleProps = {
    size?: ObjectDevices<SizeSettingGlobal>;
    backgroundColor?: StateProp<ColorValueType>;
    iconColor?: StateProp<ColorValueType>;
    boxShadowBundle?: StateProp<ShadowProps>;
    hasBoxShadowBundle?: StateProp<boolean>;
    borderBundle?: StateProp<Border>;
    roundedBundle?: StateProp<CornerRadius>;
    align?: string;
    enableHoverEffect?: boolean;
    enableActiveEffect?: boolean;
};
type ProductBundleDiscountProps = BasePropsWrap<ProductBundleDiscountSettingProps, ProductBundleDiscountStyleProps> & {
    children: React.ReactNode[];
    rawChildren?: any[];
};
type ProductBundleItemDiscountProps = {
    setSelected?: (index: number) => void;
    index: number;
    childItem?: React.ReactNode;
    rawChildrenItem?: any;
    builderProps?: any;
    bundleItem?: bundleItem | string;
    isSelected?: boolean;
    styles?: ProductBundleDiscountProps['styles'];
    setting?: ProductBundleDiscountProps['setting'];
};

type ProductQuantityLayout = 'product-quantity-square' | 'product-quantity-square-divider' | 'product-quantity-rounded' | 'product-quantity-rounded-divider' | 'product-quantity-square-input-only' | 'product-quantity-rounded-input-only';
type ProductQuantitySettingProps = {
    defaultQtyValue?: number;
    updatePrice?: boolean;
    plusIcon?: string;
    minusIcon?: string;
    hasButton?: boolean;
    enableHoverInput?: boolean;
    enableHoverButton?: boolean;
};
type ProductQuantityStyleProps = {
    quantityLayout?: ProductQuantityLayout;
    fullWidth?: ObjectDevices<boolean>;
    quantityWidth?: ObjectDevices<string | number>;
    inputHeight?: ObjectDevices<string | number | undefined>;
    buttonWidth?: ObjectDevices<string | number | undefined>;
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    align?: ObjectDevices<AlignProp>;
    inputBackgroundColor?: StateProp<ColorValueType>;
    textColor?: StateProp<ColorValueType>;
    buttonBackgroundColor?: StateProp<ColorValueType>;
    iconColor?: StateProp<ColorValueType>;
    borderBtn?: StateProp<Border>;
    iconSizeCustom?: ObjectDevices<string>;
    corner?: StateProp<CornerRadius>;
    inputBoxShadow?: StateProp<ShadowProps>;
    backgroundColor?: ObjectDevices<ColorValueType>;
    dividerColor?: StateProp<ColorValueType>;
    dividerStroke?: StateProp<number>;
    inputBorder?: StateProp<Border>;
    shapeBorder?: ObjectDevices<Border>;
    shapeRounded?: ObjectDevices<CornerRadius>;
    shapeShadow?: ObjectDevices<ShadowProps>;
};
type ProductQuantityProps = BaseProps<ProductQuantitySettingProps, ProductQuantityStyleProps>;

declare const Product$1: React.FC<ProductProps>;

declare const ProductTitle$1: React.FC<ProductTitleProps>;

declare const ProductQuantity$1: React.FC<ProductQuantityProps>;

declare const ProductDescription$2: React.FC<ProductDescriptionProps>;

declare const ProductPrice$1: React.FC<ProductPriceProps>;

declare const ProductButton$2: React.FC<ProductButtonProps>;

declare const ProductVariants$1: React.FC<ProductVariantsProps>;

declare const ProductImages$3: React.FC<ProductImagesProps>;

declare const ProductImagesV3: React.FC<ProductImagesProps$2>;

declare const ProductImagesV2: React.FC<ProductImagesProps$1>;

declare const ProductProperties$2: React.FC<ProductPropertiesProps>;

declare const QuickView: () => React.JSX.Element | null;

declare const ProductTag$2: React.FC<ProductTagProps>;

declare const ProductList$3: React.FC<ProductListProps$1>;

declare const ProductList$2: React.FC<ProductListProps>;

declare const DynamicCheckout$1: React.FC<DynamicCheckoutProps>;

declare const ProductBundleDiscount$1: React.FC<ProductBundleDiscountProps>;

declare const ProductVendor$1: React.FC<VendorProps>;

declare const ProductSku$1: React.FC<SkuProps>;

declare const ProductViewMore$2: ({ style, styles, setting, advanced, builderProps, builderAttrs, children, }: ProductViewMoreProps) => React.JSX.Element;

declare const ProductBadge$2: React.FC<ProductBadgeProps>;

declare const FileUpload$2: React.FC<FileUploadProps>;

declare const ProductBundleDiscountItem$1: React.FC<{
    children?: React.ReactNode;
}>;

declare const productSetting: {
    Product: _gem_sdk_core.ComponentSetting<ProductProps>;
    ProductQuantity: _gem_sdk_core.ComponentSetting<ProductQuantityProps>;
    ProductTitle: _gem_sdk_core.ComponentSetting<ProductTitleProps>;
    ProductButton: _gem_sdk_core.ComponentSetting<ProductButtonProps>;
    ProductPrice: _gem_sdk_core.ComponentSetting<ProductPriceProps>;
    ProductVariants: _gem_sdk_core.ComponentSetting<ProductVariantsProps>;
    ProductImages: _gem_sdk_core.ComponentSetting<ProductImagesProps>;
    ProductImagesV2: _gem_sdk_core.ComponentSetting<ProductImagesProps$1>;
    ProductImagesV3: _gem_sdk_core.ComponentSetting<ProductImagesProps$2>;
    ProductDescription: _gem_sdk_core.ComponentSetting<ProductDescriptionProps>;
    ProductProperties: _gem_sdk_core.ComponentSetting<ProductPropertiesProps>;
    ProductTag: _gem_sdk_core.ComponentSetting<ProductTagProps>;
    ProductListV3: _gem_sdk_core.ComponentSetting<ProductListProps$1>;
    ProductList: _gem_sdk_core.ComponentSetting<ProductListProps>;
    DynamicCheckout: _gem_sdk_core.ComponentSetting<ProductButtonProps>;
    ProductVendor: _gem_sdk_core.ComponentSetting<VendorProps>;
    ProductSku: _gem_sdk_core.ComponentSetting<SkuProps>;
    ProductBundleDiscount: _gem_sdk_core.ComponentSetting<ProductBundleDiscountProps>;
    ProductBundleDiscountItem: _gem_sdk_core.ComponentSetting<ProductBundleDiscountProps>;
    ProductViewMore: _gem_sdk_core.ComponentSetting<ProductViewMoreProps>;
    ProductBadge: _gem_sdk_core.ComponentSetting<ProductBadgeProps>;
    FileUpload: _gem_sdk_core.ComponentSetting<FileUploadProps>;
};

type RadioSettingProps = {
    checked?: boolean;
    label?: string;
};
type RadioStyleProps = {
    labelPlacement: string;
    size?: SizeProp;
};
type SizeProp = 'small' | 'medium' | 'large';
type RadioProps = BaseProps<RadioSettingProps, RadioStyleProps> & {
    className?: string;
    style?: React.CSSProperties;
};

declare const Radio: React.FC<RadioProps>;

declare const radioSetting: {
    Radio: _gem_sdk_core.ComponentSetting<RadioProps>;
};

type SelectSettingProps = {
    options?: string;
    arrow?: boolean;
    disabled?: HTMLSelectElement['disabled'];
    iconSvg?: string;
};
type SelectProps = BaseProps<SelectSettingProps> & {
    className?: string;
    style?: React.CSSProperties;
};

declare const Select: React.FC<SelectProps>;

declare const selectSetting: {
    Select: _gem_sdk_core.ComponentSetting<SelectProps>;
};

type Position$1 = 'top' | 'bottom' | 'left' | 'right';
type TabsSettingProps = {
    activeKey?: number;
    childItem?: string[];
    position?: ObjectDevices<Position$1>;
    labelTypo?: TypographySetting;
    labelTypoV2?: TypographySettingV2;
    panelFullWidth?: ObjectDevices<boolean>;
    panelWidth?: ObjectDevices<string>;
    panelAlign?: ObjectDevices<AlignProp>;
    panelAlignVertical?: ObjectDevices<string>;
    labelAlign?: ObjectDevices<AlignProp>;
    align?: ObjectDevices<any>;
    labelWidth?: ObjectDevices<string>;
    containWidth?: ObjectDevices<string>;
    labelColor?: StateProp<ColorValueType>;
    labelBgColor?: StateProp<ColorValueType>;
    borderTab?: StateProp<Border>;
    background?: ObjectDevices<Background>;
    padding?: ObjectDevices<SizeSettingGlobal>;
    enableHoverEffect?: boolean;
    enableActiveEffect?: boolean;
};
type TabsTranslateKeys = keyof TabsSettingProps;
type TabsProps = BasePropsWrap<TabsSettingProps> & {
    children?: React.ReactNode;
    rawChildren?: any[];
    pageContext?: PageContext;
};
type TabItemProps = {
    children?: React.ReactNode;
    className?: string;
    isActive?: boolean;
    parentUid: string;
} & BasePropsWrap & {
    parentUid?: string;
};

declare const Tabs$2: (props: TabsProps) => React.JSX.Element;

declare const TabItem$1: React.FC<TabItemProps>;

declare const tabSetting: {
    Tabs: _gem_sdk_core.ComponentSetting<TabsProps>;
    TabItem: _gem_sdk_core.ComponentSetting<TabItemProps>;
};

declare const Text$2: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<TextSettingProps, TextStyleProps, Record<string, any>> & {
    builderAttrs?: Record<string, any>;
    style?: React.CSSProperties;
} & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, ""> & {
    disableEdit?: boolean;
    pageContext?: _gem_sdk_core.PageContext;
} & React.RefAttributes<HTMLElement>>;

declare const textSetting: {
    Text: _gem_sdk_core.ComponentSetting<TextProps>;
};

type TextareaSettingProps = {
    width?: ObjectDevices<string>;
    height?: ObjectDevices<string>;
    placeholder?: string;
    fontSize?: ObjectDevices<string>;
    disabled?: boolean;
    align?: ObjectDevices<AlignProp>;
};
type TextareaProps = BaseProps<TextareaSettingProps> & {
    className?: string;
    required?: boolean;
    style?: React.CSSProperties;
    children?: React.ReactNode;
};

declare const TextArea: React.FC<TextareaProps>;

declare const textareaSetting: {
    Textarea: _gem_sdk_core.ComponentSetting<TextareaProps>;
};

type PosterProps = {
    src?: string;
    width?: number;
    height?: number;
    base64?: string;
    backupFileKey?: string;
    storage?: 'THEME' | 'FILE_CONTENT';
    preload?: boolean;
    altText?: string;
    imageTitle?: string;
};
type VideoSettingProps = {
    ratioOptions?: ObjectDevices<Ratio>;
    type?: 'youtube' | 'vimeo' | 'html5';
    lazy?: boolean;
    youtubeUrl?: string;
    vimeoUrl?: string;
    html5Url?: string;
    notes?: string;
    preload?: boolean;
    poster?: PosterProps;
    width?: ObjectDevices<number>;
    height?: ObjectDevices<number>;
    aspectRatio?: ObjectDevices<string>;
    autoplay?: boolean;
    mute?: boolean;
    loopVideo?: boolean;
    controls?: boolean;
    startTime?: string;
    endTime?: string;
};
type VideoTranslateKeys = keyof VideoSettingProps;
type VideoProps = BasePropsWrap<VideoSettingProps> & {
    className?: string;
    style?: React.CSSProperties;
    children?: React.ReactNode;
    pageContext?: PageContext;
};

declare const Video$2: React.FC<VideoProps>;

declare const videoSetting: {
    Video: _gem_sdk_core.ComponentSetting<VideoProps>;
};

declare const WISER_VERSION: {
    V1: string;
    V2: string;
};
type WiserProps = BaseProps<{
    wiserVersion?: keyof typeof WISER_VERSION;
    widgetType?: WiserWidgetType;
    widgetTypeV2?: WiserV2WidgetType;
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type DealeasyVolumeDiscountsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: string;
}>;
type AftershipEmailMarketingsmsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    formId?: string;
}>;
type AirProductReviewsAppUgcProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: AirProductReview;
}>;
type AliReviewsProps = BaseProps<{
    widgetType?: AliReviewsWidgetType;
    sticker?: boolean;
    pickSection?: {
        id: string;
        name: string;
        snippet: string;
        section: string;
    };
    sectionName?: string;
    sectionId?: string;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type AlsoBoughtCbbProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type AppointmentBookingCowlendarProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type AppstleSubscriptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type BestBuyFulfillmentProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type BfSizeChartSizeGuideProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type BirdChimeProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type BogosProps = BaseProps<{
    widgetType?: BogosWidgetType;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type BoldProductOptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type BoldSubscriptionsProps = BaseProps<{
    widgetType?: BoldSubscriptionsWidgetType;
    align?: ObjectDevices<AlignProp>;
    install?: any;
    appBlockId?: string;
    openApp?: any;
}>;
type BonLoyaltyRewardsReferralsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type BoostAISearchDiscoveryProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    widgetID?: string;
}>;
type BundlerProps = BasePropsWrap<{
    shortCode?: string;
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type CleanSizeChartsProps = BasePropsWrap<{
    chartId?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type CrossSellCartUpsellProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type CustomProductOptionsVariantProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type DiscountyBulkDiscountSalesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type EasifyProductOptionsProps = BaseProps<{
    install?: any;
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
}>;
type EasyBundleBuilderSkailamaProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type EasySellCODProps = BaseProps<{
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type EcoboostifyShoppableReelUgcProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    playlistId?: string;
}>;
type EssentialAnnouncementBarProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    announcementId?: string;
}>;
type EssentialCountdownTimerBarProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    timerId?: string;
}>;
type EstimatedDeliveryDatePlusProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type FastBundleBundlesDiscountsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType: FastBundleWidgetType;
    bundleId?: string;
}>;
declare const FERA_VERSION: {
    V2: string;
    V3: string;
};
type FeraReviewsProps = BaseProps<{
    feraVersion?: keyof typeof FERA_VERSION;
    widgetType?: FeraReviewsWidgetType;
    widgetTypeV3?: FeraReviewsV3WidgetType;
    productReviewsCode?: string;
    testimonialCarouselCode?: string;
    allReviewsCode?: string;
    averageStoreRatingBadgeCode?: string;
    inStoreMediaCode?: string;
    averageRatingBadgeCode?: string;
    productPageMediaCode?: string;
    otherWidgetCode?: string;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type FirePushProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type FlyBundlesUpsellsFbtProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    customBundleId?: string;
}>;
type FordeerProductLabelsProps = BaseProps<{
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    badgeId?: string;
    trustBadgeId?: string;
}>;
type FrequentlyBoughtTogetherProps = BaseProps<{
    targetClass?: string;
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type GloboProductOptionsVariantProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type GloColorSwatchvariantImageProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type GoogleReviewsByReputonProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: 'carousel-widget-block' | 'carousel-widget-static-plate-block' | 'compact-widget-block' | 'grid-widget-block' | 'list-widget-block' | 'masonry-widget-block' | 'sticky-compact-widget-block' | 'compact-slider-widget-block';
}>;
type GrowaveProps = BaseProps<{
    widgetTypeV2?: GrowaveWidgetTypeV2;
    widgetType?: GrowaveWidgetTypeV1;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    version?: 'v1' | 'v2';
}>;
type HextomCountdownTimerBarProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type HextomFreeShippingBarProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type HulkFormBuilderProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    formId?: string;
}>;
type HulkProductOptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type InfiniteOptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type InstafeedProps = BaseProps<{
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type InstasellShoppableInstagramProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type JudgemeReviewsProps = BaseProps<{
    widgetType?: JudgeMeReviewsWidgetType;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type JunipProductReviewsUgcProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type KachingBundlesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type KingProductOptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type KiteFreeGiftDiscountProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type KlarnaMessagingProps = BaseProps<{
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type KlaviyoProps = BasePropsWrap<{
    formCode?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type KoalaBundleQuantityDiscountProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    productHandle?: string;
    widgetType?: string;
}>;
type LaiProductReviewsProps = BasePropsWrap<{
    widgetType?: LaiProductReviewsWidgetType;
    advancedWidgetType?: LaiProductReviewsAdvancedWidgetType;
    align?: ObjectDevices<AlignProp>;
    anchorLink?: boolean;
    openApp?: any;
    install?: any;
}>;
type LoloyalLoyaltyReferralsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type LoopSubscriptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType: 'subscription_widget' | 'star_rating';
}>;
type LooxReviewsProps = BaseProps<{
    widgetType?: LooxReviewsWidgetType;
    widgetTypeV2?: LooxReviewsWidgetTypeV2;
    showAllReviews?: boolean;
    showRatingWidgetAllReviews?: boolean;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    version?: 'v1' | 'v2';
    appBlockId?: string;
}>;
type MaxbundleProductBundlesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: 'cxbundle-funnel' | 'mb-product-bundle' | 'mb-fbt-bundle' | 'mb-bogo-bundle' | 'mb-mix-match-bundle';
}>;
type MbcBundleVolumeDiscountProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type MyappgurusProductReviewsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type NotifyBackInStockPreOrderProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type OkendoReviewsLoyaltyProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type OmnisendProps = BaseProps<{
    widgetType?: OmnisendWidgetType;
    embeddedCode?: string;
    landingPageLink?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type OpinewProps = BaseProps<{
    widgetType?: OpinewWidgetType;
    design?: OpinewDesignWidgetType;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type ParcelPanelProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: string;
    appBlockId?: string;
}>;
type PickyStoryProps = BaseProps<{
    widgetType?: PickyStoryWidgetType;
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type PowerfulContactFormBuilderProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    shortcode?: string;
}>;
type PreorderNowPreOrderPqProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type PreorderNowWodPresaleProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: PreOrderNowWodWidgetType;
}>;
type ProductOptionsCustomizerProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type ProductOptionsVariantOptionProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    idTrigger?: string;
}>;
type ProductReviewsProps = BaseProps<{
    widgetType?: ProductReviewsWidgetType;
    align?: ObjectDevices<AlignProp>;
}>;
type PumperBundlesVolumeDiscountProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type PushOwlProps = BaseProps<{
    message?: string;
    subscribe?: boolean;
    action?: string;
    openApp?: any;
    install?: any;
}> & ButtonProps;
type QikifyUpsellProps = BaseProps<{
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    productHandle?: string;
}>;
type RapiBundleQuantityBreaksProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    rapdiId?: string;
}>;
type RechargeSubscriptionsProps = BaseProps<{
    appBlockId?: string;
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    productHandle?: string;
}>;
type RecurpaySubscriptionAppProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type ReleasitProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    version?: 'v1' | 'v2';
    widgetTypeV2?: string;
    appBlockId?: string;
    productHandle?: string;
}>;
type RequestQuoteHidePriceProps = BaseProps<{
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type ReviewxpoProductReviewsAppProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type RivyoProps = BaseProps<{
    widgetType?: RivyoWidgetType;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type RyviuProps = BaseProps<{
    widgetType?: RyviuWidgetType;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
}>;
type SealSubscriptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type SegunoEmailMarketingProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type SelleasyProps = BaseProps<{
    appBlockId?: string;
    widgetType?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type SeoantTrustBadgesIconProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    BadgeId?: string;
}>;
type ShopifyFormsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    formId?: string;
}>;
type ShopifySubscriptionsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type SimpleBundlesKitsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type SkioSubscriptionsYcS20Props = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    sellingPlanId?: string;
    widgetType?: string;
    appBlockId?: string;
}>;
type SmartSearchBarAndFiltersProps = BaseProps<{
    apiKey?: string;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type SproutPlantTreesGrowSalesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type StampedProps = BaseProps<{
    widgetType?: StampedWidgetType;
    widgetTypeV2?: StampedWidgetTypeV2;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
    reviewIds?: string;
    productIds?: string;
    productType?: string;
    productVendor?: string;
    tags?: string;
    limitWords?: string;
    minimumRating?: string;
    minimumCharacters?: string;
    fillEmpty?: boolean;
    random?: boolean;
    withPhotos?: boolean;
    titleColor?: string;
    starColor?: string;
    verifiedColor?: string;
    textColor?: string;
    linkColor?: string;
    badgeOuterColor?: string;
    badgeInnerColor?: string;
    badgeRibbonColor?: string;
    backgroundColor?: string;
    hoverColor?: string;
    carouselTitle?: string;
    carouselHeight?: string;
    autoSlide?: boolean;
    autoSlideInterval?: string;
    publicKey?: string;
    storeHash?: string;
    labelFront?: string;
    labelBack?: string;
    imageWidth?: string;
    imageHeight?: string;
    showProductImage?: boolean;
    limitResults?: number;
    limitQuestions?: string;
    offset?: number;
    mobileOffset?: number;
    excludeTags?: string;
    includeTags?: string;
    search?: string;
    linkify?: boolean;
    productId?: string;
    checkoutReviewsStyle?: string;
    checkoutReviewsTitle?: string;
    timeAgo?: boolean;
    instagramFeedType?: string;
    visualGalleryType?: string;
    hoverOpacity?: string;
    mainWidgetAnimation?: boolean;
    siteBadgeType?: string;
    siteBadgeTextSize?: string;
    siteBadgeHeight?: string;
    siteBadgeText?: string;
    appBlockId?: string;
    version?: 'v1' | 'v2';
}>;
type StellarDeliveryDatePickupProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type SubifySubscriptionsAppProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type TagembedSocialPostReviewProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    formCode?: string;
}>;
type TagshopShoppableVideosUgcProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    widgetType?: TagShopWidgetType;
    formCode?: string;
    tag?: string;
}>;
type TeeinblueProductPersonalizerProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type TrustBadgesBearProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type TrustedsiteTrustBadgesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    trustId?: string;
}>;
type TrustMeProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type TrustooProps = BaseProps<{
    widgetType?: TrustooWidgetType;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
    version?: 'v1' | 'v2';
    appBlockId?: string;
    productSetting?: {
        productHandle?: string;
        productId?: string;
        productImage?: string;
        productTitle?: string;
    };
}>;
type TrustreviewsProductReviewsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type TrustshopProductReviewsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    productHandle?: string;
}>;
type UltimateSalesBoostProps = BaseProps<{
    widgetType?: UltimateSalesBoostWidgetType;
    sticker?: boolean;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type UnlimitedBundlesDiscountsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type VitalsProps = BaseProps<{
    widgetType?: VitalsWidgetType;
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type WhatmoreShoppableVideosreelProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
    showViews?: string;
    templateType?: string;
    heading?: string;
    titleFontSize?: string;
    landscapePadding?: string;
    topBottomPadding?: string;
    scrollVideoTitleSize?: string;
    scrollVideoTitleSizePortrait?: string;
}>;
type WideBundleProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    install?: any;
    openApp?: any;
}>;
type WishlistKingProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type WishlistPlusProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    label?: string;
    iconSvg?: string;
}>;
type YotpoLoyaltyProps = BasePropsWrap<{
    yotpoLoyaltyCodes?: {
        guid?: string;
        yotpoWidget?: string;
    };
}, {
    align?: ObjectDevices<AlignProp>;
}>;
type YotpoReviewsProps = BaseProps<{
    widgetType?: YotpoReviewsWidgetType;
    version?: 'v1' | 'v3';
    appKey?: string;
    openApp?: any;
    install?: any;
    align?: ObjectDevices<AlignProp>;
    appBlockId?: string;
    productHandle?: string;
}>;
type EcomsendBackInStockAlertProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    productId?: string;
    widgetType?: string;
}>;
type AppstleBundlesDiscountsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type AovFreeGiftBuyXGetYBogoProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type AovBundlesVolumeDiscountsProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type UppromoteAffiliateMarketingProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type BloyRewardsProgramLoyaltyProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type KachingSubscriptionsAppProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
}>;
type GrowthSuiteDiscountCodesProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type BonySubscriptionsAppProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;
type WcWishlistBackInStockProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
    appBlockId?: string;
    widgetType?: string;
}>;
type EssentPreorderBackInStockProps = BaseProps<{
    align?: ObjectDevices<AlignProp>;
    openApp?: any;
    install?: any;
}>;

declare const RechargeSubscriptions$1: React.FC<RechargeSubscriptionsProps>;

declare const EcomsendBackInStockAlert$1: React.FC<EcomsendBackInStockAlertProps>;

declare const AppstleBundlesDiscounts$1: React.FC<AppstleBundlesDiscountsProps>;

declare const AovFreeGiftBuyXGetYBogo$1: React.FC<AovFreeGiftBuyXGetYBogoProps>;

declare const JudgemeReviews$1: React.FC<JudgemeReviewsProps>;

declare const LooxReviews$1: React.FC<LooxReviewsProps>;

declare const Klaviyo$1: React.FC<KlaviyoProps>;

declare const YotpoLoyalty: React.FC<YotpoLoyaltyProps>;

declare const SmartSearchBarAndFilters$1: React.FC<SmartSearchBarAndFiltersProps>;

declare const Instafeed$1: React.FC<InstafeedProps>;

declare const ProductReviews$1: React.FC<ProductReviewsProps>;

declare const Ryviu$1: React.FC<RyviuProps>;

declare const Rivyo$1: React.FC<RivyoProps>;

declare const Vitals$1: React.FC<VitalsProps>;

declare const Omnisend$1: React.FC<OmnisendProps>;

declare const Trustoo$1: React.FC<TrustooProps>;

declare const SealSubscriptions$1: React.FC<SealSubscriptionsProps>;

declare const AppstleSubscriptions$1: React.FC<AppstleSubscriptionsProps>;

declare const FeraReviews$1: React.FC<FeraReviewsProps>;

declare const ParcelPanel$1: React.FC<ParcelPanelProps>;

declare const TrustMe$1: React.FC<TrustMeProps>;

declare const FrequentlyBoughtTogether$1: React.FC<FrequentlyBoughtTogetherProps>;

declare const BoldSubscriptions$1: React.FC<BoldSubscriptionsProps>;

declare const BoldProductOptions$1: React.FC<BoldProductOptionsProps>;

declare const WideBundle$1: React.FC<WideBundleProps>;

declare const PickyStory$1: React.FC<PickyStoryProps>;

declare const InfiniteOptions$1: React.FC<InfiniteOptionsProps>;

declare const Wiser$1: React.FC<WiserProps>;

declare const Stamped$1: React.FC<StampedProps>;

declare const Bundler$1: React.FC<BundlerProps>;

declare const LaiProductReviews$1: React.FC<LaiProductReviewsProps>;

declare const Growave$1: React.FC<GrowaveProps>;

declare const KachingBundles$1: React.FC<KachingBundlesProps>;

declare const Opinew$1: React.FC<OpinewProps>;

declare const UltimateSalesBoost$1: React.FC<UltimateSalesBoostProps>;

declare const CrossSellCartUpsell$1: React.FC<CrossSellCartUpsellProps>;

declare const BoostAISearchDiscovery$1: React.FC<BoostAISearchDiscoveryProps>;

declare const YotpoReviews$1: React.FC<YotpoReviewsProps>;

declare const FirePush$1: React.FC<FirePushProps>;

declare const AliReviews$1: React.FC<AliReviewsProps>;

declare const CleanSizeCharts$1: React.FC<CleanSizeChartsProps>;

declare const Bogos$1: React.FC<BogosProps>;

declare const PushOwl$1: React.FC<ButtonProps>;

declare const QikifyUpsell$1: React.FC<QikifyUpsellProps>;

declare const Releasit$1: React.FC<ReleasitProps>;

declare const KingProductOptions$1: React.FC<KingProductOptionsProps>;

declare const EasySell: React.FC<EasySellCODProps>;

declare const RequestQuoteHidePrice$1: React.FC<RequestQuoteHidePriceProps>;

declare const BirdChime$1: React.FC<BirdChimeProps>;

declare const KlarnaMessaging$1: React.FC<KlarnaMessagingProps>;

declare const FordeerProductLabels$1: React.FC<FordeerProductLabelsProps>;

declare const EasifyProductOptions$1: React.FC<EasifyProductOptionsProps>;

declare const CustomProductOptionsVariant$1: React.FC<CustomProductOptionsVariantProps>;

declare const ShopifySubscriptions$1: React.FC<ShopifySubscriptionsProps>;

declare const BonLoyaltyRewardsReferrals$1: React.FC<BonLoyaltyRewardsReferralsProps>;

declare const RecurpaySubscriptionApp$1: React.FC<RecurpaySubscriptionAppProps>;

declare const SubifySubscriptionsApp$1: React.FC<SubifySubscriptionsAppProps>;

declare const Selleasy$1: React.FC<SelleasyProps>;

declare const LoopSubscriptions$1: React.FC<LoopSubscriptionsProps>;

declare const SkioSubscriptionsYcS20$1: React.FC<SkioSubscriptionsYcS20Props>;

declare const ShopifyForms$1: React.FC<ShopifyFormsProps>;

declare const NotifyBackInStockPreOrder$1: React.FC<NotifyBackInStockPreOrderProps>;

declare const ReviewxpoProductReviewsApp$1: React.FC<ReviewxpoProductReviewsAppProps>;

declare const PumperBundlesVolumeDiscount$1: React.FC<PumperBundlesVolumeDiscountProps>;

declare const UnlimitedBundlesDiscounts$1: React.FC<UnlimitedBundlesDiscountsProps>;

declare const KiteFreeGiftDiscount$1: React.FC<KiteFreeGiftDiscountProps>;

declare const FastBundleBundlesDiscounts$1: React.FC<FastBundleBundlesDiscountsProps>;

declare const SimpleBundlesKits$1: React.FC<SimpleBundlesKitsProps>;

declare const EasyBundleBuilderSkailama$1: React.FC<EasyBundleBuilderSkailamaProps>;

declare const KoalaBundleQuantityDiscount$1: React.FC<KoalaBundleQuantityDiscountProps>;

declare const PreorderNowPreOrderPq$1: React.FC<PreorderNowPreOrderPqProps>;

declare const FlyBundlesUpsellsFbt$1: React.FC<FlyBundlesUpsellsFbtProps>;

declare const JunipProductReviewsUgc$1: React.FC<JunipProductReviewsUgcProps>;

declare const MaxbundleProductBundles$1: React.FC<MaxbundleProductBundlesProps>;

declare const PreorderNowWodPresale$1: React.FC<PreorderNowWodPresaleProps>;

declare const TagshopShoppableVideosUgc$1: React.FC<TagshopShoppableVideosUgcProps>;

declare const WhatmoreShoppableVideosreel$1: React.FC<WhatmoreShoppableVideosreelProps>;

declare const ProductOptionsCustomizer$1: React.FC<ProductOptionsCustomizerProps>;

declare const TagembedSocialPostReview$1: React.FC<TagembedSocialPostReviewProps>;

declare const AirProductReviewsAppUgc$1: React.FC<AirProductReviewsAppUgcProps>;

declare const MbcBundleVolumeDiscount$1: React.FC<MbcBundleVolumeDiscountProps>;

declare const GoogleReviewsByReputon$1: React.FC<GoogleReviewsByReputonProps>;

declare const RapiBundleQuantityBreaks$1: React.FC<RapiBundleQuantityBreaksProps>;

declare const AppointmentBookingCowlendar$1: React.FC<AppointmentBookingCowlendarProps>;

declare const SproutPlantTreesGrowSales$1: React.FC<SproutPlantTreesGrowSalesProps>;

declare const InstasellShoppableInstagram$1: React.FC<InstasellShoppableInstagramProps>;

declare const WishlistPlus$1: React.FC<WishlistPlusProps>;

declare const LoloyalLoyaltyReferrals$1: React.FC<LoloyalLoyaltyReferralsProps>;

declare const HulkFormBuilder$1: React.FC<HulkFormBuilderProps>;

declare const PowerfulContactFormBuilder$1: React.FC<PowerfulContactFormBuilderProps>;

declare const WishlistKing$1: React.FC<WishlistKingProps>;

declare const TeeinblueProductPersonalizer$1: React.FC<TeeinblueProductPersonalizerProps>;

declare const GloboProductOptionsVariant$1: React.FC<GloboProductOptionsVariantProps>;

declare const ProductOptionsVariantOption$1: React.FC<ProductOptionsVariantOptionProps>;

declare const BestBuyFulfillment$1: React.FC<BestBuyFulfillmentProps>;

declare const AftershipEmailMarketingsms$1: React.FC<AftershipEmailMarketingsmsProps>;

declare const SegunoEmailMarketing$1: React.FC<SegunoEmailMarketingProps>;

declare const SeoantTrustBadgesIcon$1: React.FC<SeoantTrustBadgesIconProps>;

declare const DiscountyBulkDiscountSales$1: React.FC<DiscountyBulkDiscountSalesProps>;

declare const TrustreviewsProductReviews$1: React.FC<TrustreviewsProductReviewsProps>;

declare const MyappgurusProductReviews$1: React.FC<MyappgurusProductReviewsProps>;

declare const HulkProductOptions$1: React.FC<HulkProductOptionsProps>;

declare const TrustshopProductReviews$1: React.FC<TrustshopProductReviewsProps>;

declare const StellarDeliveryDatePickup$1: React.FC<StellarDeliveryDatePickupProps>;

declare const EssentialCountdownTimerBar$1: React.FC<EssentialCountdownTimerBarProps>;

declare const EssentialAnnouncementBar$1: React.FC<EssentialAnnouncementBarProps>;

declare const OkendoReviewsLoyalty$1: React.FC<OkendoReviewsLoyaltyProps>;

declare const EstimatedDeliveryDatePlus$1: React.FC<EstimatedDeliveryDatePlusProps>;

declare const HextomCountdownTimerBar$1: React.FC<HextomCountdownTimerBarProps>;

declare const TrustBadgesBear$1: React.FC<TrustBadgesBearProps>;

declare const TrustedsiteTrustBadges$1: React.FC<TrustedsiteTrustBadgesProps>;

declare const GloColorSwatchvariantImage$1: React.FC<GloColorSwatchvariantImageProps>;

declare const BfSizeChartSizeGuide$1: React.FC<BfSizeChartSizeGuideProps>;

declare const AlsoBoughtCbb$1: React.FC<AlsoBoughtCbbProps>;

declare const HextomFreeShippingBar$1: React.FC<HextomFreeShippingBarProps>;

declare const EcoboostifyShoppableReelUgc$1: React.FC<EcoboostifyShoppableReelUgcProps>;

declare const AovBundlesVolumeDiscounts$1: React.FC<AovBundlesVolumeDiscountsProps>;

declare const UppromoteAffiliateMarketing$1: React.FC<UppromoteAffiliateMarketingProps>;

declare const DealeasyVolumeDiscounts$1: React.FC<DealeasyVolumeDiscountsProps>;

declare const BloyRewardsProgramLoyalty$1: React.FC<BloyRewardsProgramLoyaltyProps>;

declare const KachingSubscriptionsApp$1: React.FC<KachingSubscriptionsAppProps>;

declare const GrowthSuiteDiscountCodes$1: React.FC<GrowthSuiteDiscountCodesProps>;

declare const BonySubscriptionsApp$1: React.FC<BonySubscriptionsAppProps>;

declare const WcWishlistBackInStock$1: React.FC<WcWishlistBackInStockProps>;

declare const EssentPreorderBackInStock$1: React.FC<EssentPreorderBackInStockProps>;

declare const thirdPartySetting: {
    EstimatedDeliveryDatePlus: _gem_sdk_core.ComponentSetting<EstimatedDeliveryDatePlusProps>;
    OkendoReviewsLoyalty: _gem_sdk_core.ComponentSetting<OkendoReviewsLoyaltyProps>;
    EssentialAnnouncementBar: _gem_sdk_core.ComponentSetting<EssentialAnnouncementBarProps>;
    EssentialCountdownTimerBar: _gem_sdk_core.ComponentSetting<EssentialCountdownTimerBarProps>;
    StellarDeliveryDatePickup: _gem_sdk_core.ComponentSetting<StellarDeliveryDatePickupProps>;
    TrustshopProductReviews: _gem_sdk_core.ComponentSetting<TrustshopProductReviewsProps>;
    HulkProductOptions: _gem_sdk_core.ComponentSetting<HulkProductOptionsProps>;
    MyappgurusProductReviews: _gem_sdk_core.ComponentSetting<MyappgurusProductReviewsProps>;
    TrustreviewsProductReviews: _gem_sdk_core.ComponentSetting<TrustreviewsProductReviewsProps>;
    DiscountyBulkDiscountSales: _gem_sdk_core.ComponentSetting<DiscountyBulkDiscountSalesProps>;
    SeoantTrustBadgesIcon: _gem_sdk_core.ComponentSetting<SeoantTrustBadgesIconProps>;
    SegunoEmailMarketing: _gem_sdk_core.ComponentSetting<SegunoEmailMarketingProps>;
    AftershipEmailMarketingsms: _gem_sdk_core.ComponentSetting<AftershipEmailMarketingsmsProps>;
    BestBuyFulfillment: _gem_sdk_core.ComponentSetting<BestBuyFulfillmentProps>;
    ProductOptionsVariantOption: _gem_sdk_core.ComponentSetting<ProductOptionsVariantOptionProps>;
    GloboProductOptionsVariant: _gem_sdk_core.ComponentSetting<GloboProductOptionsVariantProps>;
    TeeinblueProductPersonalizer: _gem_sdk_core.ComponentSetting<TeeinblueProductPersonalizerProps>;
    WishlistKing: _gem_sdk_core.ComponentSetting<WishlistKingProps>;
    HulkFormBuilder: _gem_sdk_core.ComponentSetting<HulkFormBuilderProps>;
    LoloyalLoyaltyReferrals: _gem_sdk_core.ComponentSetting<LoloyalLoyaltyReferralsProps>;
    PowerfulContactFormBuilder: _gem_sdk_core.ComponentSetting<PowerfulContactFormBuilderProps>;
    WishlistPlus: _gem_sdk_core.ComponentSetting<WishlistPlusProps>;
    InstasellShoppableInstagram: _gem_sdk_core.ComponentSetting<InstasellShoppableInstagramProps>;
    SproutPlantTreesGrowSales: _gem_sdk_core.ComponentSetting<SproutPlantTreesGrowSalesProps>;
    RapiBundleQuantityBreaks: _gem_sdk_core.ComponentSetting<RapiBundleQuantityBreaksProps>;
    AppointmentBookingCowlendar: _gem_sdk_core.ComponentSetting<AppointmentBookingCowlendarProps>;
    GoogleReviewsByReputon: _gem_sdk_core.ComponentSetting<GoogleReviewsByReputonProps>;
    MbcBundleVolumeDiscount: _gem_sdk_core.ComponentSetting<MbcBundleVolumeDiscountProps>;
    ProductOptionsCustomizer: _gem_sdk_core.ComponentSetting<ProductOptionsCustomizerProps>;
    AirProductReviewsAppUgc: _gem_sdk_core.ComponentSetting<AirProductReviewsAppUgcProps>;
    TagembedSocialPostReview: _gem_sdk_core.ComponentSetting<TagembedSocialPostReviewProps>;
    WhatmoreShoppableVideosreel: _gem_sdk_core.ComponentSetting<WhatmoreShoppableVideosreelProps>;
    TagshopShoppableVideosUgc: _gem_sdk_core.ComponentSetting<TagshopShoppableVideosUgcProps>;
    JunipProductReviewsUgc: _gem_sdk_core.ComponentSetting<JunipProductReviewsUgcProps>;
    FlyBundlesUpsellsFbt: _gem_sdk_core.ComponentSetting<FlyBundlesUpsellsFbtProps>;
    PreorderNowWodPresale: _gem_sdk_core.ComponentSetting<PreorderNowWodPresaleProps>;
    PreorderNowPreOrderPq: _gem_sdk_core.ComponentSetting<PreorderNowPreOrderPqProps>;
    MaxbundleProductBundles: _gem_sdk_core.ComponentSetting<MaxbundleProductBundlesProps>;
    KoalaBundleQuantityDiscount: _gem_sdk_core.ComponentSetting<KoalaBundleQuantityDiscountProps>;
    EasyBundleBuilderSkailama: _gem_sdk_core.ComponentSetting<EasyBundleBuilderSkailamaProps>;
    FastBundleBundlesDiscounts: _gem_sdk_core.ComponentSetting<FastBundleBundlesDiscountsProps>;
    KiteFreeGiftDiscount: _gem_sdk_core.ComponentSetting<KiteFreeGiftDiscountProps>;
    UnlimitedBundlesDiscounts: _gem_sdk_core.ComponentSetting<UnlimitedBundlesDiscountsProps>;
    SimpleBundlesKits: _gem_sdk_core.ComponentSetting<SimpleBundlesKitsProps>;
    ReviewxpoProductReviewsApp: _gem_sdk_core.ComponentSetting<ReviewxpoProductReviewsAppProps>;
    PumperBundlesVolumeDiscount: _gem_sdk_core.ComponentSetting<PumperBundlesVolumeDiscountProps>;
    NotifyBackInStockPreOrder: _gem_sdk_core.ComponentSetting<NotifyBackInStockPreOrderProps>;
    ShopifyForms: _gem_sdk_core.ComponentSetting<ShopifyFormsProps>;
    SkioSubscriptionsYcS20: _gem_sdk_core.ComponentSetting<SkioSubscriptionsYcS20Props>;
    LoopSubscriptions: _gem_sdk_core.ComponentSetting<LoopSubscriptionsProps>;
    RecurpaySubscriptionApp: _gem_sdk_core.ComponentSetting<RecurpaySubscriptionAppProps>;
    SubifySubscriptionsApp: _gem_sdk_core.ComponentSetting<SubifySubscriptionsAppProps>;
    BonLoyaltyRewardsReferrals: _gem_sdk_core.ComponentSetting<BonLoyaltyRewardsReferralsProps>;
    ShopifySubscriptions: _gem_sdk_core.ComponentSetting<ShopifySubscriptionsProps>;
    EasifyProductOptions: _gem_sdk_core.ComponentSetting<EasifyProductOptionsProps>;
    CustomProductOptionsVariant: _gem_sdk_core.ComponentSetting<CustomProductOptionsVariantProps>;
    EasySellCOD: _gem_sdk_core.ComponentSetting<EasySellCODProps>;
    QikifyUpsell: _gem_sdk_core.ComponentSetting<QikifyUpsellProps>;
    CleanSizeCharts: _gem_sdk_core.ComponentSetting<CleanSizeChartsProps>;
    JudgemeReviews: _gem_sdk_core.ComponentSetting<JudgemeReviewsProps>;
    LooxReviews: _gem_sdk_core.ComponentSetting<LooxReviewsProps>;
    Klaviyo: _gem_sdk_core.ComponentSetting<KlaviyoProps>;
    YotpoLoyalty: _gem_sdk_core.ComponentSetting<YotpoLoyaltyProps>;
    SmartSearchBarAndFilters: _gem_sdk_core.ComponentSetting<SmartSearchBarAndFiltersProps>;
    Instafeed: _gem_sdk_core.ComponentSetting<InstafeedProps>;
    ProductReviews: _gem_sdk_core.ComponentSetting<ProductReviewsProps>;
    Ryviu: _gem_sdk_core.ComponentSetting<RyviuProps>;
    Rivyo: _gem_sdk_core.ComponentSetting<RivyoProps>;
    Vitals: _gem_sdk_core.ComponentSetting<VitalsProps>;
    Omnisend: _gem_sdk_core.ComponentSetting<OmnisendProps>;
    Trustoo: _gem_sdk_core.ComponentSetting<TrustooProps>;
    SealSubscriptions: _gem_sdk_core.ComponentSetting<SealSubscriptionsProps>;
    AppstleSubscriptions: _gem_sdk_core.ComponentSetting<AppstleSubscriptionsProps>;
    FeraReviews: _gem_sdk_core.ComponentSetting<FeraReviewsProps>;
    Growave: _gem_sdk_core.ComponentSetting<GrowaveProps>;
    KachingBundles: _gem_sdk_core.ComponentSetting<KachingBundlesProps>;
    PushOwl: _gem_sdk_core.ComponentSetting<PushOwlProps>;
    Opinew: _gem_sdk_core.ComponentSetting<OpinewProps>;
    UltimateSalesBoost: _gem_sdk_core.ComponentSetting<UltimateSalesBoostProps>;
    FirePush: _gem_sdk_core.ComponentSetting<FirePushProps>;
    ParcelPanel: _gem_sdk_core.ComponentSetting<ParcelPanelProps>;
    TrustMe: _gem_sdk_core.ComponentSetting<TrustMeProps>;
    FrequentlyBoughtTogether: _gem_sdk_core.ComponentSetting<FrequentlyBoughtTogetherProps>;
    BoldSubscriptions: _gem_sdk_core.ComponentSetting<BoldSubscriptionsProps>;
    BoldProductOptions: _gem_sdk_core.ComponentSetting<BoldProductOptionsProps>;
    WideBundle: _gem_sdk_core.ComponentSetting<WideBundleProps>;
    PickyStory: _gem_sdk_core.ComponentSetting<PickyStoryProps>;
    InfiniteOptions: _gem_sdk_core.ComponentSetting<InfiniteOptionsProps>;
    Wiser: _gem_sdk_core.ComponentSetting<WiserProps>;
    Stamped: _gem_sdk_core.ComponentSetting<StampedProps>;
    Bundler: _gem_sdk_core.ComponentSetting<BundlerProps>;
    LaiProductReviews: _gem_sdk_core.ComponentSetting<LaiProductReviewsProps>;
    CrossSellCartUpsell: _gem_sdk_core.ComponentSetting<CrossSellCartUpsellProps>;
    BoostAISearchDiscovery: _gem_sdk_core.ComponentSetting<BoostAISearchDiscoveryProps>;
    YotpoReviews: _gem_sdk_core.ComponentSetting<YotpoReviewsProps>;
    AliReviews: _gem_sdk_core.ComponentSetting<AliReviewsProps>;
    Bogos: _gem_sdk_core.ComponentSetting<BogosProps>;
    Releasit: _gem_sdk_core.ComponentSetting<ReleasitProps>;
    KingProductOptions: _gem_sdk_core.ComponentSetting<KingProductOptionsProps>;
    KlarnaMessaging: _gem_sdk_core.ComponentSetting<KlarnaMessagingProps>;
    RequestQuoteHidePrice: _gem_sdk_core.ComponentSetting<RequestQuoteHidePriceProps>;
    BirdChime: _gem_sdk_core.ComponentSetting<BirdChimeProps>;
    FordeerProductLabels: _gem_sdk_core.ComponentSetting<FordeerProductLabelsProps>;
    RechargeSubscriptions: _gem_sdk_core.ComponentSetting<RechargeSubscriptionsProps>;
    Selleasy: _gem_sdk_core.ComponentSetting<SelleasyProps>;
    HextomCountdownTimerBar: _gem_sdk_core.ComponentSetting<HextomCountdownTimerBarProps>;
    TrustBadgesBear: _gem_sdk_core.ComponentSetting<TrustBadgesBearProps>;
    TrustedsiteTrustBadges: _gem_sdk_core.ComponentSetting<TrustedsiteTrustBadgesProps>;
    GloColorSwatchvariantImage: _gem_sdk_core.ComponentSetting<GloColorSwatchvariantImageProps>;
    BfSizeChartSizeGuide: _gem_sdk_core.ComponentSetting<BfSizeChartSizeGuideProps>;
    AlsoBoughtCbb: _gem_sdk_core.ComponentSetting<AlsoBoughtCbbProps>;
    HextomFreeShippingBar: _gem_sdk_core.ComponentSetting<HextomFreeShippingBarProps>;
    EcoboostifyShoppableReelUgc: _gem_sdk_core.ComponentSetting<EcoboostifyShoppableReelUgcProps>;
    EcomsendBackInStockAlert: _gem_sdk_core.ComponentSetting<EcomsendBackInStockAlertProps>;
    AppstleBundlesDiscounts: _gem_sdk_core.ComponentSetting<AppstleBundlesDiscountsProps>;
    AovFreeGiftBuyXGetYBogo: _gem_sdk_core.ComponentSetting<AovFreeGiftBuyXGetYBogoProps>;
    AovBundlesVolumeDiscounts: _gem_sdk_core.ComponentSetting<AovBundlesVolumeDiscountsProps>;
    UppromoteAffiliateMarketing: _gem_sdk_core.ComponentSetting<UppromoteAffiliateMarketingProps>;
    DealeasyVolumeDiscounts: _gem_sdk_core.ComponentSetting<DealeasyVolumeDiscountsProps>;
    BloyRewardsProgramLoyalty: _gem_sdk_core.ComponentSetting<BloyRewardsProgramLoyaltyProps>;
    KachingSubscriptionsApp: _gem_sdk_core.ComponentSetting<KachingSubscriptionsAppProps>;
    GrowthSuiteDiscountCodes: _gem_sdk_core.ComponentSetting<GrowthSuiteDiscountCodesProps>;
    BonySubscriptionsApp: _gem_sdk_core.ComponentSetting<BonySubscriptionsAppProps>;
    WcWishlistBackInStock: _gem_sdk_core.ComponentSetting<WcWishlistBackInStockProps>;
    EssentPreorderBackInStock: _gem_sdk_core.ComponentSetting<EssentPreorderBackInStockProps>;
};

type InstantJudgemeReviewsSettingProps = {
    widgetType?: InstantJudgeMeReviewsWidgetType;
    publicToken?: string;
};
type InstantJudgemeReviewsStyleProps = {
    align?: ObjectDevices<AlignProp>;
};
type InstantJudgemeReviewsProps = BaseProps<InstantJudgemeReviewsSettingProps, InstantJudgemeReviewsStyleProps>;
type InstantKlaviyoSettingProps = {
    klaviyoCodes?: {
        formCode?: string;
        klaviyoCode?: string;
        isEmbed?: boolean;
    };
    background?: ObjectDevices<Background>;
};
type InstantKlaviyoStyleProps = {
    align?: ObjectDevices<AlignProp>;
};
type InstantKlaviyoProps = BasePropsWrap<InstantKlaviyoSettingProps, InstantKlaviyoStyleProps>;
type InstantLooxReviewsSettingProps = {
    widgetType?: InstantLooxReviewsWidgetType;
};
type InstantLooxReviewsStyleProps = {
    align?: ObjectDevices<AlignProp>;
};
type InstantLooxReviewsProps = BaseProps<InstantLooxReviewsSettingProps, InstantLooxReviewsStyleProps>;
type InstantYotpoLoyaltySettingProps = {
    yotpoLoyaltyCodes?: {
        guid?: string;
        yotpoWidget?: string;
    };
};
type InstantYotpoLoyaltyStyleProps = {
    align?: ObjectDevices<AlignProp>;
};
type InstantYotpoLoyaltyProps = BasePropsWrap<InstantYotpoLoyaltySettingProps, InstantYotpoLoyaltyStyleProps>;

declare const InstantJudgemeReviews: React.FC<InstantJudgemeReviewsProps>;

declare const InstantLooxReviews: React.FC<InstantLooxReviewsProps>;

declare const InstantKlaviyo: React.FC<InstantKlaviyoProps>;

declare const InstantYotpoLoyalty: React.FC<InstantYotpoLoyaltyProps>;

declare const thirdPartyInstantSetting: {
    InstantJudgemeReviews: _gem_sdk_core.ComponentSetting<InstantJudgemeReviewsProps>;
    InstantLooxReviews: _gem_sdk_core.ComponentSetting<InstantLooxReviewsProps>;
    InstantKlaviyo: _gem_sdk_core.ComponentSetting<InstantKlaviyoProps>;
    InstantYotpoLoyalty: _gem_sdk_core.ComponentSetting<InstantYotpoLoyaltyProps>;
};

type StockCounterSettingProps = {
    displayByDefault?: boolean;
    scarcityThreshold?: number;
    remainingPercentage?: number | string;
    showIcon?: boolean;
    hiddenCounterWhenOutOfStock?: boolean;
    icon?: string;
    template?: string;
    outOfStockMessage?: string;
    continueSelling?: string;
    unlimitedQuantityMessage?: string;
    layout?: 'full' | 'text-and-progress-bar' | 'icon-and-text' | 'progress-bar' | 'text-only';
    oosIcon?: string;
    progressBarPosition?: 'top' | 'bottom';
    iconPosition?: 'left' | 'right';
    iconSize?: ObjectDevices<number | ''>;
};
type StockCounterStyleProps = {
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    alignment?: ObjectDevices<AlignProp>;
    /**
     * @deprecated please use `typo` instead
     */
    typography?: TypographySetting;
    typo?: TypographySettingV2;
    color?: ColorValueType;
    iconColor?: ColorValueType;
    textColor?: ColorValueType;
    displayProgressBar?: boolean;
    progressBarHeight?: ObjectDevices<number | string>;
    roundedBorder?: boolean;
    effect?: boolean;
    oosIconColor?: ColorValueType;
    oosTextColor?: ColorValueType;
    borderRadius?: CornerRadius;
};
type StockCounterTranslateKeys = keyof StockCounterSettingProps;
type StockCounterProps = BasePropsWrap<StockCounterSettingProps, StockCounterStyleProps> & {
    pageContext: PageContext;
};

declare const StockCounter$2: React.FC<StockCounterProps>;

declare const stockCounterSetting: {
    StockCounter: _gem_sdk_core.ComponentSetting<StockCounterProps>;
};

type ThirdPartySlotSettingProps = {
    setupGuide?: string;
    index?: number;
};
type AnyShopifyAppsProps = BaseProps<ThirdPartySlotSettingProps>;

declare const ThirdPartySlot$1: React.FC<AnyShopifyAppsProps>;

declare const thirdPartySlotSetting: {
    ThirdPartySlot: _gem_sdk_core.ComponentSetting<AnyShopifyAppsProps>;
};

type ShopPayInstallmentSettingProps = {
    setupGuide?: string;
};
type ShopPayInstallmentProps = BaseProps<ShopPayInstallmentSettingProps>;

declare const ShopPayInstallments$1: React.FC<ShopPayInstallmentProps>;

declare const shopPayInstallmentSetting: {
    ShopPayInstallments: _gem_sdk_core.ComponentSetting<ShopPayInstallmentProps>;
};

type Position = 'top' | 'bottom';
type DisplayOptionValue = 'always' | 'after-first-scroll' | 'after-first-cart-button' | 'meet-section';
type StickySettingProps = {
    display: ObjectDevices<DisplayOptionValue>;
    fullWidth?: ObjectDevices<boolean>;
    width?: ObjectDevices<string>;
    background: ObjectDevices<BackgroundMedia>;
    position: ObjectDevices<Position>;
    padding?: ObjectDevices<string>;
    preloadBgImage?: boolean;
    isScrollToTop?: boolean;
    minimize?: boolean;
};
type StickyTranslateKeys = keyof StickySettingProps;
type StickyProps = BasePropsWrap<StickySettingProps> & {
    children?: React.ReactNode;
    pageContext?: PageContext;
};

declare const Sticky$2: React$1.FC<StickyProps>;

declare const stickySetting: {
    Sticky: _gem_sdk_core.ComponentSetting<StickyProps>;
};

declare const _default$4: {
    Sticky: React.ComponentType<StickyProps>;
    ShopPayInstallments: React.ComponentType<ShopPayInstallmentProps>;
    ThirdPartySlot: React.ComponentType<AnyShopifyAppsProps>;
    StockCounter: React.ComponentType<StockCounterProps>;
    InstantJudgemeReviews: React.ComponentType<InstantJudgemeReviewsProps>;
    InstantLooxReviews: React.ComponentType<InstantLooxReviewsProps>;
    InstantKlaviyo: React.ComponentType<InstantKlaviyoProps>;
    InstantYotpoLoyalty: React.ComponentType<InstantYotpoLoyaltyProps>;
    EssentPreorderBackInStock: React.ComponentType<EssentPreorderBackInStockProps>;
    WcWishlistBackInStock: React.ComponentType<WcWishlistBackInStockProps>;
    BonySubscriptionsApp: React.ComponentType<BonySubscriptionsAppProps>;
    GrowthSuiteDiscountCodes: React.ComponentType<GrowthSuiteDiscountCodesProps>;
    KachingSubscriptionsApp: React.ComponentType<KachingSubscriptionsAppProps>;
    BloyRewardsProgramLoyalty: React.ComponentType<BloyRewardsProgramLoyaltyProps>;
    DealeasyVolumeDiscounts: React.ComponentType<DealeasyVolumeDiscountsProps>;
    UppromoteAffiliateMarketing: React.ComponentType<UppromoteAffiliateMarketingProps>;
    AovBundlesVolumeDiscounts: React.ComponentType<AovBundlesVolumeDiscountsProps>;
    AovFreeGiftBuyXGetYBogo: React.ComponentType<AovFreeGiftBuyXGetYBogoProps>;
    EcomsendBackInStockAlert: React.ComponentType<EcomsendBackInStockAlertProps>;
    AppstleBundlesDiscounts: React.ComponentType<AppstleBundlesDiscountsProps>;
    EcoboostifyShoppableReelUgc: React.ComponentType<EcoboostifyShoppableReelUgcProps>;
    EstimatedDeliveryDatePlus: React.ComponentType<EstimatedDeliveryDatePlusProps>;
    OkendoReviewsLoyalty: React.ComponentType<OkendoReviewsLoyaltyProps>;
    EssentialAnnouncementBar: React.ComponentType<EssentialAnnouncementBarProps>;
    EssentialCountdownTimerBar: React.ComponentType<EssentialCountdownTimerBarProps>;
    StellarDeliveryDatePickup: React.ComponentType<StellarDeliveryDatePickupProps>;
    TrustshopProductReviews: React.ComponentType<TrustshopProductReviewsProps>;
    HulkProductOptions: React.ComponentType<HulkProductOptionsProps>;
    MyappgurusProductReviews: React.ComponentType<MyappgurusProductReviewsProps>;
    TrustreviewsProductReviews: React.ComponentType<TrustreviewsProductReviewsProps>;
    DiscountyBulkDiscountSales: React.ComponentType<DiscountyBulkDiscountSalesProps>;
    SeoantTrustBadgesIcon: React.ComponentType<SeoantTrustBadgesIconProps>;
    SegunoEmailMarketing: React.ComponentType<SegunoEmailMarketingProps>;
    AftershipEmailMarketingsms: React.ComponentType<AftershipEmailMarketingsmsProps>;
    BestBuyFulfillment: React.ComponentType<BestBuyFulfillmentProps>;
    ProductOptionsVariantOption: React.ComponentType<ProductOptionsVariantOptionProps>;
    GloboProductOptionsVariant: React.ComponentType<GloboProductOptionsVariantProps>;
    TeeinblueProductPersonalizer: React.ComponentType<TeeinblueProductPersonalizerProps>;
    WishlistKing: React.ComponentType<WishlistKingProps>;
    HulkFormBuilder: React.ComponentType<HulkFormBuilderProps>;
    LoloyalLoyaltyReferrals: React.ComponentType<LoloyalLoyaltyReferralsProps>;
    PowerfulContactFormBuilder: React.ComponentType<PowerfulContactFormBuilderProps>;
    WishlistPlus: React.ComponentType<WishlistPlusProps>;
    InstasellShoppableInstagram: React.ComponentType<InstasellShoppableInstagramProps>;
    SproutPlantTreesGrowSales: React.ComponentType<SproutPlantTreesGrowSalesProps>;
    RapiBundleQuantityBreaks: React.ComponentType<RapiBundleQuantityBreaksProps>;
    AppointmentBookingCowlendar: React.ComponentType<AppointmentBookingCowlendarProps>;
    GoogleReviewsByReputon: React.ComponentType<GoogleReviewsByReputonProps>;
    MbcBundleVolumeDiscount: React.ComponentType<MbcBundleVolumeDiscountProps>;
    ProductOptionsCustomizer: React.ComponentType<ProductOptionsCustomizerProps>;
    AirProductReviewsAppUgc: React.ComponentType<AirProductReviewsAppUgcProps>;
    TagembedSocialPostReview: React.ComponentType<TagembedSocialPostReviewProps>;
    WhatmoreShoppableVideosreel: React.ComponentType<WhatmoreShoppableVideosreelProps>;
    TagshopShoppableVideosUgc: React.ComponentType<TagshopShoppableVideosUgcProps>;
    JunipProductReviewsUgc: React.ComponentType<JunipProductReviewsUgcProps>;
    FlyBundlesUpsellsFbt: React.ComponentType<FlyBundlesUpsellsFbtProps>;
    PreorderNowWodPresale: React.ComponentType<PreorderNowWodPresaleProps>;
    PreorderNowPreOrderPq: React.ComponentType<PreorderNowPreOrderPqProps>;
    MaxbundleProductBundles: React.ComponentType<MaxbundleProductBundlesProps>;
    KoalaBundleQuantityDiscount: React.ComponentType<KoalaBundleQuantityDiscountProps>;
    EasyBundleBuilderSkailama: React.ComponentType<EasyBundleBuilderSkailamaProps>;
    FastBundleBundlesDiscounts: React.ComponentType<FastBundleBundlesDiscountsProps>;
    KiteFreeGiftDiscount: React.ComponentType<KiteFreeGiftDiscountProps>;
    UnlimitedBundlesDiscounts: React.ComponentType<UnlimitedBundlesDiscountsProps>;
    SimpleBundlesKits: React.ComponentType<SimpleBundlesKitsProps>;
    ReviewxpoProductReviewsApp: React.ComponentType<ReviewxpoProductReviewsAppProps>;
    PumperBundlesVolumeDiscount: React.ComponentType<PumperBundlesVolumeDiscountProps>;
    NotifyBackInStockPreOrder: React.ComponentType<NotifyBackInStockPreOrderProps>;
    ShopifyForms: React.ComponentType<ShopifyFormsProps>;
    SkioSubscriptionsYcS20: React.ComponentType<SkioSubscriptionsYcS20Props>;
    LoopSubscriptions: React.ComponentType<LoopSubscriptionsProps>;
    Selleasy: React.ComponentType<SelleasyProps>;
    RecurpaySubscriptionApp: React.ComponentType<RecurpaySubscriptionAppProps>;
    SubifySubscriptionsApp: React.ComponentType<SubifySubscriptionsAppProps>;
    BonLoyaltyRewardsReferrals: React.ComponentType<BonLoyaltyRewardsReferralsProps>;
    ShopifySubscriptions: React.ComponentType<ShopifySubscriptionsProps>;
    EasifyProductOptions: React.ComponentType<EasifyProductOptionsProps>;
    CustomProductOptionsVariant: React.ComponentType<CustomProductOptionsVariantProps>;
    KlarnaMessaging: React.ComponentType<KlarnaMessagingProps>;
    RechargeSubscriptions: React.ComponentType<RechargeSubscriptionsProps>;
    EasySellCOD: React.ComponentType<EasySellCODProps>;
    QikifyUpsell: React.ComponentType<QikifyUpsellProps>;
    CleanSizeCharts: React.ComponentType<CleanSizeChartsProps>;
    JudgemeReviews: React.ComponentType<JudgemeReviewsProps>;
    LooxReviews: React.ComponentType<LooxReviewsProps>;
    Klaviyo: React.ComponentType<KlaviyoProps>;
    YotpoLoyalty: React.ComponentType<YotpoLoyaltyProps>;
    SmartSearchBarAndFilters: React.ComponentType<SmartSearchBarAndFiltersProps>;
    Instafeed: React.ComponentType<InstafeedProps>;
    ProductReviews: React.ComponentType<ProductReviewsProps>;
    Ryviu: React.ComponentType<RyviuProps>;
    Rivyo: React.ComponentType<RivyoProps>;
    Vitals: React.ComponentType<VitalsProps>;
    Omnisend: React.ComponentType<OmnisendProps>;
    ParcelPanel: React.ComponentType<ParcelPanelProps>;
    TrustMe: React.ComponentType<TrustMeProps>;
    KingProductOptions: React.ComponentType<KingProductOptionsProps>;
    Trustoo: React.ComponentType<TrustooProps>;
    SealSubscriptions: React.ComponentType<SealSubscriptionsProps>;
    AppstleSubscriptions: React.ComponentType<AppstleSubscriptionsProps>;
    FeraReviews: React.ComponentType<FeraReviewsProps>;
    Growave: React.ComponentType<GrowaveProps>;
    KachingBundles: React.ComponentType<KachingBundlesProps>;
    PushOwl: React.ComponentType<ButtonProps>;
    Opinew: React.ComponentType<OpinewProps>;
    UltimateSalesBoost: React.ComponentType<UltimateSalesBoostProps>;
    FirePush: React.ComponentType<FirePushProps>;
    FrequentlyBoughtTogether: React.ComponentType<FrequentlyBoughtTogetherProps>;
    BoldSubscriptions: React.ComponentType<BoldSubscriptionsProps>;
    BoldProductOptions: React.ComponentType<BoldProductOptionsProps>;
    WideBundle: React.ComponentType<WideBundleProps>;
    PickyStory: React.ComponentType<PickyStoryProps>;
    InfiniteOptions: React.ComponentType<InfiniteOptionsProps>;
    Wiser: React.ComponentType<WiserProps>;
    Stamped: React.ComponentType<StampedProps>;
    Bundler: React.ComponentType<BundlerProps>;
    LaiProductReviews: React.ComponentType<LaiProductReviewsProps>;
    CrossSellCartUpsell: React.ComponentType<CrossSellCartUpsellProps>;
    BoostAISearchDiscovery: React.ComponentType<BoostAISearchDiscoveryProps>;
    YotpoReviews: React.ComponentType<YotpoReviewsProps>;
    AliReviews: React.ComponentType<AliReviewsProps>;
    Bogos: React.ComponentType<BogosProps>;
    Releasit: React.ComponentType<ReleasitProps>;
    RequestQuoteHidePrice: React.ComponentType<RequestQuoteHidePriceProps>;
    BirdChime: React.ComponentType<BirdChimeProps>;
    FordeerProductLabels: React.ComponentType<FordeerProductLabelsProps>;
    HextomCountdownTimerBar: React.ComponentType<HextomCountdownTimerBarProps>;
    TrustBadgesBear: React.ComponentType<TrustBadgesBearProps>;
    TrustedsiteTrustBadges: React.ComponentType<TrustedsiteTrustBadgesProps>;
    GloColorSwatchvariantImage: React.ComponentType<GloColorSwatchvariantImageProps>;
    BfSizeChartSizeGuide: React.ComponentType<BfSizeChartSizeGuideProps>;
    AlsoBoughtCbb: React.ComponentType<AlsoBoughtCbbProps>;
    HextomFreeShippingBar: React.ComponentType<HextomFreeShippingBarProps>;
    Video: React.ComponentType<VideoProps>;
    Textarea: React.ComponentType<TextareaProps>;
    Text: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<TextSettingProps, TextStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, ""> & {
        disableEdit?: boolean;
        pageContext?: _gem_sdk_core.PageContext;
    } & React.RefAttributes<HTMLElement>>;
    Tabs: React.ComponentType<TabsProps>;
    TabItem: React.ComponentType<TabItemProps>;
    Select: React.ComponentType<SelectProps>;
    Radio: React.ComponentType<RadioProps>;
    Product: React.ComponentType<ProductProps>;
    ProductTitle: React.ComponentType<ProductTitleProps>;
    ProductQuantity: React.ComponentType<ProductQuantityProps>;
    ProductPrice: React.ComponentType<ProductPriceProps>;
    ProductButton: React.ComponentType<ProductButtonProps>;
    ProductDescription: React.ComponentType<ProductDescriptionProps>;
    ProductVariants: React.ComponentType<ProductVariantsProps>;
    ProductImages: React.ComponentType<ProductImagesProps>;
    ProductImagesV3: React.ComponentType<ProductImagesProps$2>;
    ProductImagesV2: React.ComponentType<ProductImagesProps$1>;
    ProductProperties: React.ComponentType<ProductPropertiesProps>;
    ProductQuickView: React.ComponentType<{}>;
    ProductTag: React.ComponentType<ProductTagProps>;
    ProductListV3: React.ComponentType<ProductListProps$1>;
    ProductList: React.ComponentType<ProductListProps>;
    DynamicCheckout: React.ComponentType<DynamicCheckoutProps>;
    ProductVendor: React.ComponentType<VendorProps>;
    ProductViewMore: React.ComponentType<ProductViewMoreProps>;
    ProductBadge: React.ComponentType<ProductBadgeProps>;
    ProductBundleDiscount: React.ComponentType<ProductBundleDiscountProps>;
    ProductBundleDiscountItem: React.ComponentType<{
        children?: React.ReactNode;
    }>;
    ProductSku: React.ComponentType<SkuProps>;
    FileUpload: React.ComponentType<FileUploadProps>;
    PostPurchaseBuyerConsent: React.ComponentType<PostPurchaseBuyerConsentProps>;
    PostPurchaseProductTitle: React.ComponentType<PostPurchaseProductTitleProps>;
    PostPurchaseProductDescription: React.ComponentType<PostPurchaseProductDescriptionProps>;
    PostPurchaseProductPrice: React.ComponentType<PostPurchaseProductPriceProps>;
    PostPurchaseProductVariants: React.ComponentType<PostPurchaseProductVariantsProps>;
    PostPurchaseAcceptButton: React.ComponentType<PostPurchaseButtonProps>;
    PostPurchaseProductQuantity: React.ComponentType<PostPurchaseProductQuantityProps>;
    PostPurchaseProductPriceBreakdown: React.ComponentType<PostPurchaseProductPriceBreakdownProps>;
    PostPurchaseProductOffer: React.ComponentType<PostPurchaseProductOfferProps>;
    PostPurchaseProductDiscountTag: React.ComponentType<PostPurchaseProductDiscountTagProps>;
    PostPurchaseProductImages: React.ComponentType<PostPurchaseProductImagesProps>;
    PostPurchaseProductSubscription: React.ComponentType<PostPurchaseProductSubscriptionProps>;
    PostPurchaseText: React.ComponentType<PostPurchaseTextProps>;
    PostPurchaseHeading: React.ComponentType<PostPurchaseTextProps>;
    PostPurchaseLink: React.ComponentType<PostPurchaseLinkProps>;
    PostPurchaseLine: React.ComponentType<PostPurchaseLineProps>;
    PostPurchaseImage: React.ComponentType<PostPurchaseImageProps>;
    PostPurchaseCountdownTimer: React.ComponentType<{}>;
    PostPurchaseCalloutBox: React.ComponentType<CalloutBoxProps>;
    PostPurchaseCalloutText: React.ComponentType<CalloutTextProps>;
    PostPurchaseButton: React.ComponentType<_gem_sdk_core.BaseProps<{
        text?: string | number;
        buttonType?: "primary" | "secondary" | "link";
        outOfStockLabel?: string;
        requireAcceptTermLabel?: string;
    }, {
        typo?: _gem_sdk_core.PostPurchaseTypo;
        align?: "start" | "end" | "center";
        width?: _gem_sdk_core.ObjectDevices<string>;
        direction?: "ltr" | "rtl";
    }, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        disabled: boolean;
    }>;
    PostPurchaseAdvancedList: React.ComponentType<PostPurchaseAdvancedListProps>;
    PostPurchaseAdvancedListItem: React.ComponentType<PostPurchaseAdvancedListItemProps>;
    Pagination: React.ComponentType<PaginationProps>;
    Modal: React.ComponentType<ModalProps>;
    Menu: React.ComponentType<MenuProps>;
    Marquee: React.ComponentType<MarqueeProps>;
    MarqueeItem: React.ComponentType<MarqueeItemProps>;
    Link: React.ComponentType<NextLinkProps>;
    Line: React.ComponentType<LineProps>;
    Input: React.ComponentType<InputProps>;
    ImageDetection: React.ComponentType<ImageDetectionProps>;
    ImageComparison: React.ComponentType<ImageComparisonProps>;
    Image: React.FC<ImageProps>;
    IconListV2: React.ComponentType<IconListProps>;
    IconListHoz: React.ComponentType<IconListHozProps>;
    IconListItemHoz: React.ComponentType<IconListItemProps>;
    IconList: React.ComponentType<IconListProps$1>;
    IconListItem: React.ComponentType<IconListItemProps$1>;
    Icon: React.ComponentType<IconProps>;
    Heading: React.FC<HeadingProps>;
    Header: React.ComponentType<HeaderProps>;
    Row: React.FC<RowProps>;
    Col: React.FC<ColProps>;
    Section: React.FC<RowProps>;
    Root: React.FC<{
        children?: React.ReactNode;
    }>;
    Newsletter: React.ComponentType<NewsletterProps>;
    FormEmail: React.ComponentType<FormEmailProps>;
    SubmitButton: React.ComponentType<SubmitButtonProps>;
    Contact: React.ComponentType<NewsletterProps>;
    ContactForm: React.ComponentType<NewsletterProps>;
    TextField: React.ComponentType<TextFieldProps>;
    FormTextarea: React.ComponentType<TextAreaProps>;
    FormTextArea: React.ComponentType<TextAreaProps>;
    FormDropdown: React.ComponentType<FormDropdownProps>;
    FormCheckbox: React.ComponentType<FormCheckboxProps>;
    TextInput: React.ComponentType<TextInputProps>;
    EstimateDate: React.ComponentType<EstimateDateProps>;
    Dialog: React.ComponentType<DialogProps$1>;
    Coupon: React.ComponentType<CouponProps>;
    Countdown: React.ComponentType<CountdownProps>;
    CollectionTitle: React.ComponentType<CollectionTitleProps>;
    CollectionDescription: React.ComponentType<CollectionDescriptionProps>;
    CollectionToolbar: React.ComponentType<CollectionToolbarProps>;
    CollectionPaginator: React.ComponentType<CollectionPaginatorProps>;
    CollectionBanner: React.ComponentType<CollectionBannerProps>;
    CSSCode: React.ComponentType<CSSCodeProps>;
    Cart: React.ComponentType<CartProps>;
    CartList: React.ComponentType<CartListProps>;
    CartLinePrice: React.ComponentType<CartLinePriceProps>;
    CartLineVariant: React.ComponentType<CartLineVariantProps>;
    CartLineImage: React.ComponentType<CartLineImageProps>;
    CartTotalPrice: React.ComponentType<CartTotalPriceProps>;
    CartTotalItem: React.ComponentType<CartTotalItemProps>;
    CartCheckout: React.ComponentType<CartCheckoutProps>;
    DiscountInput: React.ComponentType<DiscountInputProps>;
    CartDiscount: React.ComponentType<CartDiscountProps>;
    CartOrderNote: React.ComponentType<CartOrderNoteProps>;
    CartLineAttribute: React.ComponentType<CartLineAttributeProps>;
    CouponList: React.ComponentType<{}>;
    ShopPayButton: React.ComponentType<ShopPayButtonProps>;
    CheckoutNow: React.ComponentType<CheckoutNowProps>;
    CarouselV3: React.ComponentType<_gem_sdk_core.BaseProps<CarouselSettingProps$1, CarouselStyleProps$1, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        onSwiperReady?: (swiper: _gem_sdk_swiper.default) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
        isDisableResetSlide?: boolean;
        isProductList?: boolean;
        thumbsSwiper?: string;
        productBadgeLiquid?: string;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
        isEnableCheckHasScrollableContent?: boolean;
    } & React.RefAttributes<CarouselRef$1>>;
    CarouselItemV3: React.ComponentType<CarouselItemProps$1>;
    Carousel: React.ComponentType<_gem_sdk_core.BaseProps<CarouselSettingProps, CarouselStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
    } & React.RefAttributes<CarouselRef>>;
    CarouselItem: React.ComponentType<CarouselItemProps>;
    Button: React.ComponentType<ButtonProps>;
    Breadcrumb: React.ComponentType<BreadcrumbProps>;
    HeroBanner: React.ComponentType<HeroBannerProps>;
    ArticleList: React.ComponentType<ArticleListProps>;
    ArticleTitle: React.ComponentType<ArticleTitleProps>;
    ArticleExcerpt: React.ComponentType<ArticleExcerptProps>;
    ArticleContent: React.ComponentType<ArticleContentProps>;
    ArticleImage: React.ComponentType<ArticleImageProps>;
    ArticlePagination: React.ComponentType<CollectionPaginatorProps>;
    ArticleAuthor: React.ComponentType<ArticleAuthorProps>;
    ArticleTag: React.ComponentType<ArticleTagProps>;
    ArticleCategory: React.ComponentType<ArticleCategoryProps>;
    ArticleDate: React.ComponentType<ArticleDateProps>;
    ArticleReadMore: React.ComponentType<ArticleReadMoreProps>;
    Accordion: React.ComponentType<AccordionProps>;
    AccordionItem: React.ComponentType<AccordionItemProps>;
};

declare const _default$3: {
    Sticky: React.ComponentType<StickyProps>;
    ThirdPartySlot: React.ComponentType<AnyShopifyAppsProps>;
    StockCounter: React.ComponentType<StockCounterProps>;
    InstantJudgemeReviews: React.ComponentType<InstantJudgemeReviewsProps>;
    InstantLooxReviews: React.ComponentType<InstantLooxReviewsProps>;
    InstantKlaviyo: React.ComponentType<InstantKlaviyoProps>;
    InstantYotpoLoyalty: React.ComponentType<InstantYotpoLoyaltyProps>;
    Video: React.ComponentType<VideoProps>;
    Textarea: React.ComponentType<TextareaProps>;
    Text: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<TextSettingProps, TextStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, ""> & {
        disableEdit?: boolean;
        pageContext?: _gem_sdk_core.PageContext;
    } & React.RefAttributes<HTMLElement>>;
    Tabs: React.ComponentType<TabsProps>;
    TabItem: React.ComponentType<TabItemProps>;
    Select: React.ComponentType<SelectProps>;
    Radio: React.ComponentType<RadioProps>;
    Product: React.ComponentType<ProductProps>;
    ProductTitle: React.ComponentType<ProductTitleProps>;
    ProductQuantity: React.ComponentType<ProductQuantityProps>;
    ProductPrice: React.ComponentType<ProductPriceProps>;
    ProductButton: React.ComponentType<ProductButtonProps>;
    ProductDescription: React.ComponentType<ProductDescriptionProps>;
    ProductVariants: React.ComponentType<ProductVariantsProps>;
    ProductImages: React.ComponentType<ProductImagesProps>;
    ProductImagesV3: React.ComponentType<ProductImagesProps$2>;
    ProductImagesV2: React.ComponentType<ProductImagesProps$1>;
    ProductProperties: React.ComponentType<ProductPropertiesProps>;
    ProductQuickView: React.ComponentType<{}>;
    ProductTag: React.ComponentType<ProductTagProps>;
    ProductListV3: React.ComponentType<ProductListProps$1>;
    ProductList: React.ComponentType<ProductListProps>;
    DynamicCheckout: React.ComponentType<DynamicCheckoutProps>;
    ProductVendor: React.ComponentType<VendorProps>;
    ProductViewMore: React.ComponentType<ProductViewMoreProps>;
    ProductBadge: React.ComponentType<ProductBadgeProps>;
    ProductBundleDiscount: React.ComponentType<ProductBundleDiscountProps>;
    ProductBundleDiscountItem: React.ComponentType<{
        children?: React.ReactNode;
    }>;
    ProductSku: React.ComponentType<SkuProps>;
    FileUpload: React.ComponentType<FileUploadProps>;
    Pagination: React.ComponentType<PaginationProps>;
    Modal: React.ComponentType<ModalProps>;
    Menu: React.ComponentType<MenuProps>;
    Marquee: React.ComponentType<MarqueeProps>;
    MarqueeItem: React.ComponentType<MarqueeItemProps>;
    Link: React.ComponentType<NextLinkProps>;
    Line: React.ComponentType<LineProps>;
    Input: React.ComponentType<InputProps>;
    ImageComparison: React.ComponentType<ImageComparisonProps>;
    Image: React.FC<ImageProps>;
    IconListV2: React.ComponentType<IconListProps>;
    IconListHoz: React.ComponentType<IconListHozProps>;
    IconListItemHoz: React.ComponentType<IconListItemProps>;
    IconList: React.ComponentType<IconListProps$1>;
    IconListItem: React.ComponentType<IconListItemProps$1>;
    Icon: React.ComponentType<IconProps>;
    Heading: React.FC<HeadingProps>;
    Header: React.ComponentType<HeaderProps>;
    Row: React.FC<RowProps>;
    Col: React.FC<ColProps>;
    Section: React.FC<RowProps>;
    Root: React.FC<{
        children?: React.ReactNode;
    }>;
    Newsletter: React.ComponentType<NewsletterProps>;
    FormEmail: React.ComponentType<FormEmailProps>;
    SubmitButton: React.ComponentType<SubmitButtonProps>;
    Contact: React.ComponentType<NewsletterProps>;
    ContactForm: React.ComponentType<NewsletterProps>;
    TextField: React.ComponentType<TextFieldProps>;
    FormTextarea: React.ComponentType<TextAreaProps>;
    FormTextArea: React.ComponentType<TextAreaProps>;
    FormDropdown: React.ComponentType<FormDropdownProps>;
    FormCheckbox: React.ComponentType<FormCheckboxProps>;
    TextInput: React.ComponentType<TextInputProps>;
    EstimateDate: React.ComponentType<EstimateDateProps>;
    Dialog: React.ComponentType<DialogProps$1>;
    Coupon: React.ComponentType<CouponProps>;
    Countdown: React.ComponentType<CountdownProps>;
    CollectionTitle: React.ComponentType<CollectionTitleProps>;
    CollectionDescription: React.ComponentType<CollectionDescriptionProps>;
    CollectionToolbar: React.ComponentType<CollectionToolbarProps>;
    CollectionPaginator: React.ComponentType<CollectionPaginatorProps>;
    CollectionBanner: React.ComponentType<CollectionBannerProps>;
    CSSCode: React.ComponentType<CSSCodeProps>;
    Cart: React.ComponentType<CartProps>;
    CartList: React.ComponentType<CartListProps>;
    CartLinePrice: React.ComponentType<CartLinePriceProps>;
    CartLineVariant: React.ComponentType<CartLineVariantProps>;
    CartLineImage: React.ComponentType<CartLineImageProps>;
    CartTotalPrice: React.ComponentType<CartTotalPriceProps>;
    CartTotalItem: React.ComponentType<CartTotalItemProps>;
    CartCheckout: React.ComponentType<CartCheckoutProps>;
    DiscountInput: React.ComponentType<DiscountInputProps>;
    CartDiscount: React.ComponentType<CartDiscountProps>;
    CartOrderNote: React.ComponentType<CartOrderNoteProps>;
    CartLineAttribute: React.ComponentType<CartLineAttributeProps>;
    CouponList: React.ComponentType<{}>;
    ShopPayButton: React.ComponentType<ShopPayButtonProps>;
    CheckoutNow: React.ComponentType<CheckoutNowProps>;
    CarouselV3: React.ComponentType<_gem_sdk_core.BaseProps<CarouselSettingProps$1, CarouselStyleProps$1, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        onSwiperReady?: (swiper: _gem_sdk_swiper.default) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
        isDisableResetSlide?: boolean;
        isProductList?: boolean;
        thumbsSwiper?: string;
        productBadgeLiquid?: string;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
        isEnableCheckHasScrollableContent?: boolean;
    } & React.RefAttributes<CarouselRef$1>>;
    CarouselItemV3: React.ComponentType<CarouselItemProps$1>;
    Carousel: React.ComponentType<_gem_sdk_core.BaseProps<CarouselSettingProps, CarouselStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
    } & React.RefAttributes<CarouselRef>>;
    CarouselItem: React.ComponentType<CarouselItemProps>;
    Button: React.ComponentType<ButtonProps>;
    Breadcrumb: React.ComponentType<BreadcrumbProps>;
    HeroBanner: React.ComponentType<HeroBannerProps>;
    ArticleList: React.ComponentType<ArticleListProps>;
    ArticleTitle: React.ComponentType<ArticleTitleProps>;
    ArticleExcerpt: React.ComponentType<ArticleExcerptProps>;
    ArticleContent: React.ComponentType<ArticleContentProps>;
    ArticleImage: React.ComponentType<ArticleImageProps>;
    ArticlePagination: React.ComponentType<CollectionPaginatorProps>;
    ArticleAuthor: React.ComponentType<ArticleAuthorProps>;
    ArticleTag: React.ComponentType<ArticleTagProps>;
    ArticleCategory: React.ComponentType<ArticleCategoryProps>;
    ArticleDate: React.ComponentType<ArticleDateProps>;
    ArticleReadMore: React.ComponentType<ArticleReadMoreProps>;
    Accordion: React.ComponentType<AccordionProps>;
    AccordionItem: React.ComponentType<AccordionItemProps>;
};

type AccordionPropsLiquid = AccordionProps & {
    rawChildren?: any[];
    pageContext?: PageContext;
};
declare const Accordion$1: ({ rawChildren, setting, styles, builderProps, pageContext, advanced, style, builderAttrs, }: AccordionPropsLiquid) => string;

type LiquidAccordionItemProps = AccordionItemProps & {
    rawChildren?: any[];
    parentUid?: any;
};
declare const AccordionItem: (props: LiquidAccordionItemProps) => string;

declare const ArticleList: (props: ArticleListProps) => string;

declare const ArticleTitle: ({ setting, styles, advanced, builderProps }: ArticleTitleProps) => string;

declare const ArticleExcerpt: ({ setting, styles, advanced, builderProps }: ArticleTitleProps) => string;

declare const ArticleContent: ({ styles, builderProps }: ArticleTitleProps) => string;

declare const ArticleImage: (props: ArticleImageProps) => string;

declare const ArticlePagination$1: (props: CollectionPaginatorProps) => string;

declare const ArticleAuthor: ({ setting, styles, advanced, builderProps }: ArticleAuthorProps) => string;

declare const ArticleTag: ({ setting, styles, advanced, builderProps }: ArticleTagProps) => string;

declare const ArticleCategory: ({ setting, styles, advanced, builderProps }: ArticleTagProps) => string;

declare const ArticleDate: ({ setting, styles, advanced, builderProps }: ArticleDateProps) => string;

declare const ArticleReadMore$1: ({ setting, styles, builderAttrs, builderProps, advanced, style, pageContext, }: ArticleReadMoreProps) => string;

declare const HeroBanner$1: (props: HeroBannerProps) => string;

declare const Breadcrumb: ({ setting, builderAttrs, style, styles, className, builderProps, advanced, }: BreadcrumbProps) => string;

declare const Button$1: (props: ButtonLiquidProps) => string;

declare const CarouselItem$1: (props: CarouselItemProps$1) => string;

declare const Carousel$1: (props: CarouselProps$1) => string;

declare const CarouselItem: (props: CarouselItemProps) => string;

declare const Carousel: (props: CarouselProps) => string;

/**
 * The `ShopPayButton` component renders a button that redirects to the Shop Pay checkout.
 */
declare const ShopPayButton: ({ style, styles, setting, className, builderAttrs }: ShopPayButtonProps) => string;

declare const CSSCode$1: ({ setting, style, advanced, builderAttrs, builderProps, pageContext, }: CSSCodeProps) => string;

declare const CollectionToolbar$1: ({ setting, builderProps, pageContext }: CollectionToolbarProps) => string;

declare const CollectionTitle: ({ setting, advanced }: CollectionTitleProps) => string;

declare const CollectionDescription$1: ({ setting, advanced, builderProps, pageContext, }: CollectionDescriptionProps) => string | JSX.Element | null;

declare const CollectionPaginator$1: ({ setting, builderProps, pageContext }: CollectionPaginatorProps) => string;

declare const CollectionBanner: ({ builderAttrs, builderProps, setting, style, children, rawChildren, advanced, }: CollectionBannerProps & {
    rawChildren?: any[];
    advanced?: any;
}) => string;

declare const Countdown$1: (props: CountdownProps) => string;

declare const Coupon$1: ({ setting, builderProps, builderAttrs, style, styles, advanced, pageContext, }: CouponProps) => string;

declare const Dialog$1: (props: DialogProps$1) => string;

declare const EstimateDate$1: ({ setting, styles, builderAttrs, style, builderProps, advanced, isText, pageContext, }: EstimateDateProps & {
    pageContext?: PageContext;
    isText?: boolean;
}) => string;

type RootProps = {
    children?: string;
};
declare const Root: ({ children }: RootProps) => string | undefined;

declare const Section$1: (props: RowProps) => string;

declare const Row$1: (props: RowProps) => string;

declare const Column: (props: ColProps) => string;

declare const Newsletter$1: ({ builderProps, setting, children, style, formType, advanced, pageContext, styles, }: NewsletterProps) => string;

declare const ContactForm$1: ({ builderProps, setting, children, style, advanced, pageContext, styles, }: NewsletterProps) => string;

declare const FormEmail$1: ({ builderProps, builderAttrs, setting, advanced, pageContext, styles, }: FormEmailProps & {
    pageContext?: PageContext;
}) => string;

declare const SubmitButton$1: ({ setting, builderProps, builderAttrs, style, styles, advanced, pageContext, }: SubmitButtonProps & {
    pageContext?: PageContext;
}) => string;

declare const TextField$1: ({ setting, builderProps, className, builderAttrs, advanced, pageContext, styles, }: TextFieldProps & {
    pageContext?: PageContext;
}) => string;

declare const FormTextarea$1: ({ setting, builderProps, className, builderAttrs, advanced, pageContext, styles, }: TextAreaProps & {
    pageContext?: PageContext;
}) => string;

declare const FormDropdown$1: ({ builderProps, setting, advanced, pageContext, styles, }: FormDropdownProps & {
    pageContext?: PageContext;
}) => string;

declare const FromCheckbox: ({ builderProps, setting, advanced, pageContext, styles, }: FormCheckboxProps & {
    pageContext?: PageContext;
}) => string;

declare const TextInput$1: ({ setting, builderProps, className, builderAttrs, advanced, pageContext, styles, }: TextInputProps & {
    pageContext?: PageContext;
}) => string;

declare const Heading$1: ({ styles, builderAttrs, style, setting, advanced, builderProps, isText, className, pageContext, ...props }: HeadingProps & {
    isText?: boolean;
    pageContext?: PageContext;
}) => string;

declare const Icon: ({ style, builderAttrs, builderProps, setting, styles, advanced }: IconProps) => string;

declare const IconListItem: ({ children, dataIndex, parentUid, builderProps, parentStyles, }: IconListItemProps$1) => string | null;

declare const IconList$1: ({ builderProps, style, setting, rawChildren, styles, advanced, pageContext, }: IconListProps$1) => string;

declare const IconListHoz: (props: IconListHozProps) => string;

declare const IconListIHozItemLiquid: ({ children, builderAttrs }: IconListItemProps) => string;

declare const IconListV2$1: (props: IconListProps) => string;

declare const Image$1: ({ style, styles, setting, advanced, className, pageContext, builderAttrs, builderProps, }: ImageLiquidProps) => string;

declare const ImageComparison$1: ({ setting, styles, builderProps, advanced, pageContext, ...props }: ImageComparisonProps) => string;

declare const Line: (props: LineProps) => string;

declare const MarqueeItem: ({ builderProps, itemBackgroundColor, itemBorderStyle, itemCorner, itemShadow, rawChildren, itemStyles, hasItemShadow, }: MarqueeItemProps & {
    rawChildren: RawChild[];
    itemStyles: Record<string, string>;
}) => string;

declare const Marquee: ({ children, style, builderAttrs, rawChildren, advanced, ...props }: MarqueeProps) => string;

declare const Text$1: ({ id, styles, builderAttrs, style, setting, advanced, builderProps, className, isText, pageContext, translateSetting, elementAttrs, }: TextProps & {
    isText?: boolean;
    advanced?: any;
    pageContext?: PageContext;
    elementAttrs?: Record<string, any>;
    isForceValue?: boolean;
    translateSetting?: string;
}) => string;

declare const DynamicCheckout: ({ builderProps, styles, advanced, setting, pageContext, }: DynamicCheckoutLiquidProps) => string;

declare const FileUpload$1: ({ setting, styles, builderProps, pageContext }: FileUploadProps) => string;

declare const Product: (props: ProductProps) => string;

declare const ProductBadge$1: (props: ProductBadgeProps & {
    pageContext?: PageContext;
}) => string;

declare const ProductBundleDiscount: ({ rawChildren, setting, styles, advanced, style, }: ProductBundleDiscountProps) => string;

declare const ProductBundleDiscountItem: ({ children }: any) => any;

declare const ProductButton$1: (props: ProductButtonProps & {
    pageContext?: PageContext;
}) => string;

declare const ProductDescription$1: (props: ProductDescriptionProps) => string;

declare const ProductImages$2: (productImageProps: ProductImagesProps) => string;

declare const ProductQuantity: ({ setting, styles, advanced, builderProps, }: ProductQuantityProps) => string;

declare const ProductVariants: (props: ProductVariantsProps) => string;

declare const ProductTag$1: ({ setting, styles, builderProps, advanced, pageContext, }: ProductTagProps & {
    pageContext?: PageContext;
}) => string;

type PropTypes$1 = ProductImagesProps$1 & React.ComponentPropsWithoutRef<'div'> & {
    rawChildren?: any[];
    children?: any;
} & {
    pageContext?: PageContext;
    enableLazyLoadImage?: boolean;
};
declare const ProductImages$1: (props: PropTypes$1) => string;

type PropTypes = ProductImagesProps$2 & React.ComponentPropsWithoutRef<'div'> & {
    rawChildren?: any[];
    children?: any;
} & {
    pageContext?: PageContext;
    enableLazyLoadImage?: boolean;
};
declare const ProductImages: (props: PropTypes) => string;

declare const ProductList$1: (props: ProductListProps$1) => string;

declare const ProductList: (props: ProductListProps) => string;

declare const ProductPrice: (props: ProductPriceProps) => string;

declare const ProductProperties$1: ({ setting, styles, builderProps, advanced, pageContext, }: ProductPropertiesProps & {
    pageContext?: PageContext;
}) => string;

declare const ProductTitle: (props: ProductTitleProps) => string;

declare const ProductVendor: ({ setting, styles, advanced, builderProps }: VendorProps) => string;

declare const ProductViewMore$1: ({ style, styles, setting, advanced, builderProps, builderAttrs, pageContext, }: ProductViewMoreProps & {
    pageContext?: PageContext;
}) => string;

declare const ProductSku: ({ setting, styles, advanced, builderProps }: SkuProps) => string;

declare const Video$1: ({ className, setting, style, builderAttrs, builderProps, advanced, pageContext, }: VideoProps) => string;

declare const config: ComponentSetting<VideoProps>;

declare const Tabs$1: (props: TabsProps) => string;

declare const TabItem: (props: TabItemProps) => string;

declare const StockCounter$1: ({ setting, styles, style, advanced, builderProps, pageContext, }: StockCounterProps) => string;

declare const Klaviyo: ({ setting, advanced }: KlaviyoProps) => string;

declare const SmartSearchBarAndFilters: ({ setting, advanced }: SmartSearchBarAndFiltersProps) => string;

declare const LooxReviews: ({ setting, advanced }: LooxReviewsProps) => string;

declare const Instafeed: ({ setting, advanced }: InstafeedProps) => string;

declare const CrossSellCartUpsell: ({ setting, advanced }: CrossSellCartUpsellProps) => string;

declare const BoostAISearchDiscovery: ({ setting, advanced }: BoostAISearchDiscoveryProps) => string;

declare const JudgemeReviews: ({ setting, advanced }: JudgemeReviewsProps) => string;

declare const ProductReviews: ({ setting, advanced }: ProductReviewsProps) => string;

declare const Ryviu: ({ setting, advanced }: RyviuProps) => string;

declare const Rivyo: ({ setting, advanced }: RivyoProps) => string;

declare const Vitals: ({ setting, advanced }: VitalsProps) => string;

declare const Omnisend: ({ setting, advanced }: OmnisendProps) => string;

declare const Trustoo: ({ setting, advanced }: TrustooProps) => string;

declare const SealSubscriptions: ({ setting, advanced }: SealSubscriptionsProps) => string;

declare const AppstleSubscriptions: ({ setting, advanced }: AppstleSubscriptionsProps) => string;

declare const FeraReviews: ({ setting, advanced }: FeraReviewsProps) => string;

declare const Growave: ({ setting, advanced }: GrowaveProps) => string;

declare const Opinew: ({ setting, advanced }: OpinewProps) => string;

declare const UltimateSalesBoost: ({ setting, advanced }: UltimateSalesBoostProps) => string;

declare const AliReviews: ({ setting, advanced }: AliReviewsProps) => string;

declare const FirePush: ({ setting, advanced }: FirePushProps) => string;

declare const ParcelPanel: ({ setting, advanced }: ParcelPanelProps) => string;

declare const TrustMe: ({ setting, advanced }: TrustMeProps) => string;

declare const FrequentlyBoughtTogether: ({ setting, advanced }: FrequentlyBoughtTogetherProps) => string;

declare const BoldSubscriptions: ({ setting, advanced }: BoldSubscriptionsProps) => string;

declare const BoldProductOptions: ({ setting, advanced }: BoldProductOptionsProps) => string;

declare const WideBundle: ({ setting, advanced }: WideBundleProps) => string;

declare const PickyStory: ({ setting, advanced }: PickyStoryProps) => string;

declare const InfiniteOptions: ({ setting, advanced }: InfiniteOptionsProps) => string;

declare const Wiser: ({ setting, advanced }: WiserProps) => string;

declare const Stamped: ({ setting, advanced }: StampedProps) => string;

declare const Bundler: ({ setting, advanced }: BundlerProps) => string;

declare const LaiProductReviews: ({ setting, advanced }: LaiProductReviewsProps) => string;

declare const YotpoReviews: ({ setting, advanced }: YotpoReviewsProps) => string;

declare const KachingBundles: ({ setting, advanced }: KachingBundlesProps) => string;

declare const CleanSizeCharts: ({ setting, advanced }: CleanSizeChartsProps) => string;

declare const PushOwl: ({ setting, style, styles, advanced, builderProps, builderAttrs, }: PushOwlProps) => string;

declare const Bogos: ({ setting, advanced }: BogosProps) => string;

declare const QikifyUpsell: ({ setting, advanced }: QikifyUpsellProps) => string;

declare const Releasit: ({ setting, advanced }: ReleasitProps) => string;

declare const KingProductOptions: ({ setting, advanced }: KingProductOptionsProps) => string;

declare const EasySellCOD: ({ setting, advanced }: EasySellCODProps) => string;

declare const RequestQuoteHidePrice: ({ setting, advanced }: RequestQuoteHidePriceProps) => string;

declare const BirdChime: ({ setting, advanced }: VitalsProps) => string;

declare const KlarnaMessaging: ({ setting, advanced }: KlarnaMessagingProps) => string;

declare const FordeerProductLabels: ({ setting, advanced }: FordeerProductLabelsProps) => string;

declare const EasifyProductOptions: ({ setting, advanced }: EasifyProductOptionsProps) => string;

declare const CustomProductOptionsVariant: ({ setting, advanced }: CustomProductOptionsVariantProps) => string;

declare const ShopifySubscriptions: ({ setting, advanced }: ShopifySubscriptionsProps) => string;

declare const RechargeSubscriptions: ({ setting, advanced }: RechargeSubscriptionsProps) => string;

declare const BonLoyaltyRewardsReferrals: ({ setting, advanced }: BonLoyaltyRewardsReferralsProps) => string;

declare const RecurpaySubscriptionApp: ({ setting, advanced }: RecurpaySubscriptionAppProps) => string;

declare const SubifySubscriptionsApp: ({ setting, advanced }: SubifySubscriptionsAppProps) => string;

declare const Selleasy: ({ setting, advanced }: SelleasyProps) => string;

declare const LoopSubscriptions: ({ setting, advanced }: LoopSubscriptionsProps) => string;

declare const SkioSubscriptionsYcS20: ({ setting, advanced }: SkioSubscriptionsYcS20Props) => string;

declare const ShopifyForms: ({ setting, advanced }: ShopifyFormsProps) => string;

declare const NotifyBackInStockPreOrder: ({ setting, advanced }: NotifyBackInStockPreOrderProps) => string;

declare const ReviewxpoProductReviewsApp: ({ setting, advanced }: ReviewxpoProductReviewsAppProps) => string;

declare const PumperBundlesVolumeDiscount: ({ setting, advanced }: PumperBundlesVolumeDiscountProps) => string;

declare const UnlimitedBundlesDiscounts: ({ setting, advanced }: UnlimitedBundlesDiscountsProps) => string;

declare const KiteFreeGiftDiscount: ({ setting, advanced }: KiteFreeGiftDiscountProps) => string;

declare const FastBundleBundlesDiscounts: ({ setting, advanced }: FastBundleBundlesDiscountsProps) => string;

declare const SimpleBundlesKits: ({ setting, advanced }: SimpleBundlesKitsProps) => string;

declare const EasyBundleBuilderSkailama: ({ setting, advanced }: EasyBundleBuilderSkailamaProps) => string;

declare const KoalaBundleQuantityDiscount: ({ setting, advanced }: KoalaBundleQuantityDiscountProps) => string;

declare const PreorderNowPreOrderPq: ({ setting, advanced }: PreorderNowPreOrderPqProps) => string;

declare const FlyBundlesUpsellsFbt: ({ setting, advanced }: FlyBundlesUpsellsFbtProps) => string;

declare const JunipProductReviewsUgc: ({ setting, advanced }: JunipProductReviewsUgcProps) => string;

declare const MaxbundleProductBundles: ({ setting, advanced }: MaxbundleProductBundlesProps) => string;

declare const PreorderNowWodPresale: ({ setting, advanced }: PreorderNowWodPresaleProps) => string;

declare const TagshopShoppableVideosUgc: ({ setting, advanced }: TagshopShoppableVideosUgcProps) => string;

declare const WhatmoreShoppableVideosreel: ({ setting, advanced }: WhatmoreShoppableVideosreelProps) => string;

declare const ProductOptionsCustomizer: ({ setting, advanced }: ProductOptionsCustomizerProps) => string;

declare const TagembedSocialPostReview: ({ setting, advanced }: TagembedSocialPostReviewProps) => string;

declare const AirProductReviewsAppUgc: ({ setting, advanced }: AirProductReviewsAppUgcProps) => string;

declare const MbcBundleVolumeDiscount: ({ setting, advanced }: MbcBundleVolumeDiscountProps) => string;

declare const GoogleReviewsByReputon: ({ setting, advanced }: GoogleReviewsByReputonProps) => string;

declare const RapiBundleQuantityBreaks: ({ setting, advanced }: RapiBundleQuantityBreaksProps) => string;

declare const AppointmentBookingCowlendar: ({ setting, advanced }: AppointmentBookingCowlendarProps) => string;

declare const SproutPlantTreesGrowSales: ({ setting, advanced }: SproutPlantTreesGrowSalesProps) => string;

declare const InstasellShoppableInstagram: ({ setting, advanced }: InstasellShoppableInstagramProps) => string;

declare const WishlistPlus: ({ setting, advanced }: WishlistPlusProps) => string;

declare const LoloyalLoyaltyReferrals: ({ setting, advanced }: LoloyalLoyaltyReferralsProps) => string;

declare const HulkFormBuilder: ({ setting, advanced }: HulkFormBuilderProps) => string;

declare const PowerfulContactFormBuilder: ({ setting, advanced }: PowerfulContactFormBuilderProps) => string;

declare const WishlistKing: ({ setting, advanced }: WishlistKingProps) => string;

declare const TeeinblueProductPersonalizer: ({ setting, advanced }: TeeinblueProductPersonalizerProps) => string;

declare const GloboProductOptionsVariant: ({ setting, advanced }: GloboProductOptionsVariantProps) => string;

declare const ProductOptionsVariantOption: ({ setting, advanced }: ProductOptionsVariantOptionProps) => string;

declare const BestBuyFulfillment: ({ setting, advanced }: BestBuyFulfillmentProps) => string;

declare const AftershipEmailMarketingsms: ({ setting, advanced }: AftershipEmailMarketingsmsProps) => string;

declare const SegunoEmailMarketing: ({ setting, advanced }: SegunoEmailMarketingProps) => string;

declare const SeoantTrustBadgesIcon: ({ setting, advanced }: SeoantTrustBadgesIconProps) => string;

declare const DiscountyBulkDiscountSales: ({ setting, advanced }: DiscountyBulkDiscountSalesProps) => string;

declare const TrustreviewsProductReviews: ({ setting, advanced }: TrustreviewsProductReviewsProps) => string;

declare const MyappgurusProductReviews: ({ setting, advanced }: MyappgurusProductReviewsProps) => string;

declare const HulkProductOptions: ({ setting, advanced }: HulkProductOptionsProps) => string;

declare const EssentialCountdownTimerBar: ({ setting, advanced }: EssentialCountdownTimerBarProps) => string;

declare const EssentialAnnouncementBar: ({ setting, advanced }: EssentialAnnouncementBarProps) => string;

declare const OkendoReviewsLoyalty: ({ setting, advanced }: OkendoReviewsLoyaltyProps) => string;

declare const EstimatedDeliveryDatePlus: ({ setting, advanced }: EstimatedDeliveryDatePlusProps) => string;

declare const HextomCountdownTimerBar: ({ setting, advanced }: HextomCountdownTimerBarProps) => string;

declare const TrustBadgesBear: ({ setting, advanced }: TrustBadgesBearProps) => string;

declare const TrustedsiteTrustBadges: ({ setting, advanced }: TrustedsiteTrustBadgesProps) => string;

declare const GloColorSwatchvariantImage: ({ setting, advanced }: GloColorSwatchvariantImageProps) => string;

declare const BfSizeChartSizeGuide: ({ setting, advanced }: BfSizeChartSizeGuideProps) => string;

declare const AlsoBoughtCbb: ({ setting, advanced }: AlsoBoughtCbbProps) => string;

declare const HextomFreeShippingBar: ({ setting, advanced }: HextomFreeShippingBarProps) => string;

declare const EcoboostifyShoppableReelUgc: ({ setting, advanced }: EcoboostifyShoppableReelUgcProps) => string;

declare const EcomsendBackInStockAlert: ({ setting, advanced }: EcomsendBackInStockAlertProps) => string;

declare const AppstleBundlesDiscounts: ({ setting, advanced }: AppstleBundlesDiscountsProps) => string;

declare const AovFreeGiftBuyXGetYBogo: ({ setting, advanced }: AovFreeGiftBuyXGetYBogoProps) => string;

declare const AovBundlesVolumeDiscounts: ({ setting, advanced }: AovBundlesVolumeDiscountsProps) => string;

declare const UppromoteAffiliateMarketing: ({ setting, advanced }: UppromoteAffiliateMarketingProps) => string;

declare const DealeasyVolumeDiscounts: ({ setting, advanced }: DealeasyVolumeDiscountsProps) => string;

declare const BloyRewardsProgramLoyalty: ({ setting, advanced }: BloyRewardsProgramLoyaltyProps) => string;

declare const KachingSubscriptionsApp: ({ setting, advanced }: KachingSubscriptionsAppProps) => string;

declare const GrowthSuiteDiscountCodes: ({ setting, advanced }: GrowthSuiteDiscountCodesProps) => string;

declare const BonySubscriptionsApp: ({ setting, advanced }: BonySubscriptionsAppProps) => string;

declare const WcWishlistBackInStock: ({ setting, advanced }: WcWishlistBackInStockProps) => string;

declare const EssentPreorderBackInStock: ({ setting, advanced }: EssentPreorderBackInStockProps) => string;

declare const TrustshopProductReviews: ({ setting, advanced }: TrustshopProductReviewsProps) => string;

declare const StellarDeliveryDatePickup: ({ setting, advanced }: StellarDeliveryDatePickupProps) => string;

declare const ThirdPartySlot: (props: AnyShopifyAppsProps) => string | JSX.Element;

declare const ShopPayInstallments: () => string;

declare const Sticky$1: ({ children, builderAttrs, setting, style, builderProps, advanced, pageContext, }: StickyProps) => string;

declare const index_liquid_AccordionItem: typeof AccordionItem;
declare const index_liquid_AftershipEmailMarketingsms: typeof AftershipEmailMarketingsms;
declare const index_liquid_AirProductReviewsAppUgc: typeof AirProductReviewsAppUgc;
declare const index_liquid_AliReviews: typeof AliReviews;
declare const index_liquid_AlsoBoughtCbb: typeof AlsoBoughtCbb;
declare const index_liquid_AovBundlesVolumeDiscounts: typeof AovBundlesVolumeDiscounts;
declare const index_liquid_AovFreeGiftBuyXGetYBogo: typeof AovFreeGiftBuyXGetYBogo;
declare const index_liquid_AppointmentBookingCowlendar: typeof AppointmentBookingCowlendar;
declare const index_liquid_AppstleBundlesDiscounts: typeof AppstleBundlesDiscounts;
declare const index_liquid_AppstleSubscriptions: typeof AppstleSubscriptions;
declare const index_liquid_ArticleAuthor: typeof ArticleAuthor;
declare const index_liquid_ArticleCategory: typeof ArticleCategory;
declare const index_liquid_ArticleContent: typeof ArticleContent;
declare const index_liquid_ArticleDate: typeof ArticleDate;
declare const index_liquid_ArticleExcerpt: typeof ArticleExcerpt;
declare const index_liquid_ArticleImage: typeof ArticleImage;
declare const index_liquid_ArticleList: typeof ArticleList;
declare const index_liquid_ArticleTag: typeof ArticleTag;
declare const index_liquid_ArticleTitle: typeof ArticleTitle;
declare const index_liquid_BestBuyFulfillment: typeof BestBuyFulfillment;
declare const index_liquid_BfSizeChartSizeGuide: typeof BfSizeChartSizeGuide;
declare const index_liquid_BirdChime: typeof BirdChime;
declare const index_liquid_BloyRewardsProgramLoyalty: typeof BloyRewardsProgramLoyalty;
declare const index_liquid_Bogos: typeof Bogos;
declare const index_liquid_BoldProductOptions: typeof BoldProductOptions;
declare const index_liquid_BoldSubscriptions: typeof BoldSubscriptions;
declare const index_liquid_BonLoyaltyRewardsReferrals: typeof BonLoyaltyRewardsReferrals;
declare const index_liquid_BonySubscriptionsApp: typeof BonySubscriptionsApp;
declare const index_liquid_BoostAISearchDiscovery: typeof BoostAISearchDiscovery;
declare const index_liquid_Breadcrumb: typeof Breadcrumb;
declare const index_liquid_Bundler: typeof Bundler;
declare const index_liquid_Carousel: typeof Carousel;
declare const index_liquid_CarouselItem: typeof CarouselItem;
declare const index_liquid_CleanSizeCharts: typeof CleanSizeCharts;
declare const index_liquid_CollectionBanner: typeof CollectionBanner;
declare const index_liquid_CollectionTitle: typeof CollectionTitle;
declare const index_liquid_CrossSellCartUpsell: typeof CrossSellCartUpsell;
declare const index_liquid_CustomProductOptionsVariant: typeof CustomProductOptionsVariant;
declare const index_liquid_DealeasyVolumeDiscounts: typeof DealeasyVolumeDiscounts;
declare const index_liquid_DiscountyBulkDiscountSales: typeof DiscountyBulkDiscountSales;
declare const index_liquid_DynamicCheckout: typeof DynamicCheckout;
declare const index_liquid_EasifyProductOptions: typeof EasifyProductOptions;
declare const index_liquid_EasyBundleBuilderSkailama: typeof EasyBundleBuilderSkailama;
declare const index_liquid_EasySellCOD: typeof EasySellCOD;
declare const index_liquid_EcoboostifyShoppableReelUgc: typeof EcoboostifyShoppableReelUgc;
declare const index_liquid_EcomsendBackInStockAlert: typeof EcomsendBackInStockAlert;
declare const index_liquid_EssentPreorderBackInStock: typeof EssentPreorderBackInStock;
declare const index_liquid_EssentialAnnouncementBar: typeof EssentialAnnouncementBar;
declare const index_liquid_EssentialCountdownTimerBar: typeof EssentialCountdownTimerBar;
declare const index_liquid_EstimatedDeliveryDatePlus: typeof EstimatedDeliveryDatePlus;
declare const index_liquid_FastBundleBundlesDiscounts: typeof FastBundleBundlesDiscounts;
declare const index_liquid_FeraReviews: typeof FeraReviews;
declare const index_liquid_FirePush: typeof FirePush;
declare const index_liquid_FlyBundlesUpsellsFbt: typeof FlyBundlesUpsellsFbt;
declare const index_liquid_FordeerProductLabels: typeof FordeerProductLabels;
declare const index_liquid_FrequentlyBoughtTogether: typeof FrequentlyBoughtTogether;
declare const index_liquid_GloColorSwatchvariantImage: typeof GloColorSwatchvariantImage;
declare const index_liquid_GloboProductOptionsVariant: typeof GloboProductOptionsVariant;
declare const index_liquid_GoogleReviewsByReputon: typeof GoogleReviewsByReputon;
declare const index_liquid_Growave: typeof Growave;
declare const index_liquid_GrowthSuiteDiscountCodes: typeof GrowthSuiteDiscountCodes;
declare const index_liquid_HextomCountdownTimerBar: typeof HextomCountdownTimerBar;
declare const index_liquid_HextomFreeShippingBar: typeof HextomFreeShippingBar;
declare const index_liquid_HulkFormBuilder: typeof HulkFormBuilder;
declare const index_liquid_HulkProductOptions: typeof HulkProductOptions;
declare const index_liquid_Icon: typeof Icon;
declare const index_liquid_IconListHoz: typeof IconListHoz;
declare const index_liquid_IconListItem: typeof IconListItem;
declare const index_liquid_InfiniteOptions: typeof InfiniteOptions;
declare const index_liquid_Instafeed: typeof Instafeed;
declare const index_liquid_InstasellShoppableInstagram: typeof InstasellShoppableInstagram;
declare const index_liquid_JudgemeReviews: typeof JudgemeReviews;
declare const index_liquid_JunipProductReviewsUgc: typeof JunipProductReviewsUgc;
declare const index_liquid_KachingBundles: typeof KachingBundles;
declare const index_liquid_KachingSubscriptionsApp: typeof KachingSubscriptionsApp;
declare const index_liquid_KingProductOptions: typeof KingProductOptions;
declare const index_liquid_KiteFreeGiftDiscount: typeof KiteFreeGiftDiscount;
declare const index_liquid_KlarnaMessaging: typeof KlarnaMessaging;
declare const index_liquid_Klaviyo: typeof Klaviyo;
declare const index_liquid_KoalaBundleQuantityDiscount: typeof KoalaBundleQuantityDiscount;
declare const index_liquid_LaiProductReviews: typeof LaiProductReviews;
declare const index_liquid_Line: typeof Line;
declare const index_liquid_LoloyalLoyaltyReferrals: typeof LoloyalLoyaltyReferrals;
declare const index_liquid_LoopSubscriptions: typeof LoopSubscriptions;
declare const index_liquid_LooxReviews: typeof LooxReviews;
declare const index_liquid_Marquee: typeof Marquee;
declare const index_liquid_MarqueeItem: typeof MarqueeItem;
declare const index_liquid_MaxbundleProductBundles: typeof MaxbundleProductBundles;
declare const index_liquid_MbcBundleVolumeDiscount: typeof MbcBundleVolumeDiscount;
declare const index_liquid_MyappgurusProductReviews: typeof MyappgurusProductReviews;
declare const index_liquid_NotifyBackInStockPreOrder: typeof NotifyBackInStockPreOrder;
declare const index_liquid_OkendoReviewsLoyalty: typeof OkendoReviewsLoyalty;
declare const index_liquid_Omnisend: typeof Omnisend;
declare const index_liquid_Opinew: typeof Opinew;
declare const index_liquid_ParcelPanel: typeof ParcelPanel;
declare const index_liquid_PickyStory: typeof PickyStory;
declare const index_liquid_PowerfulContactFormBuilder: typeof PowerfulContactFormBuilder;
declare const index_liquid_PreorderNowPreOrderPq: typeof PreorderNowPreOrderPq;
declare const index_liquid_PreorderNowWodPresale: typeof PreorderNowWodPresale;
declare const index_liquid_Product: typeof Product;
declare const index_liquid_ProductBundleDiscount: typeof ProductBundleDiscount;
declare const index_liquid_ProductBundleDiscountItem: typeof ProductBundleDiscountItem;
declare const index_liquid_ProductList: typeof ProductList;
declare const index_liquid_ProductOptionsCustomizer: typeof ProductOptionsCustomizer;
declare const index_liquid_ProductOptionsVariantOption: typeof ProductOptionsVariantOption;
declare const index_liquid_ProductPrice: typeof ProductPrice;
declare const index_liquid_ProductQuantity: typeof ProductQuantity;
declare const index_liquid_ProductReviews: typeof ProductReviews;
declare const index_liquid_ProductSku: typeof ProductSku;
declare const index_liquid_ProductTitle: typeof ProductTitle;
declare const index_liquid_ProductVariants: typeof ProductVariants;
declare const index_liquid_ProductVendor: typeof ProductVendor;
declare const index_liquid_PumperBundlesVolumeDiscount: typeof PumperBundlesVolumeDiscount;
declare const index_liquid_PushOwl: typeof PushOwl;
declare const index_liquid_QikifyUpsell: typeof QikifyUpsell;
declare const index_liquid_RapiBundleQuantityBreaks: typeof RapiBundleQuantityBreaks;
declare const index_liquid_RechargeSubscriptions: typeof RechargeSubscriptions;
declare const index_liquid_RecurpaySubscriptionApp: typeof RecurpaySubscriptionApp;
declare const index_liquid_Releasit: typeof Releasit;
declare const index_liquid_RequestQuoteHidePrice: typeof RequestQuoteHidePrice;
declare const index_liquid_ReviewxpoProductReviewsApp: typeof ReviewxpoProductReviewsApp;
declare const index_liquid_Rivyo: typeof Rivyo;
declare const index_liquid_Root: typeof Root;
declare const index_liquid_Ryviu: typeof Ryviu;
declare const index_liquid_SealSubscriptions: typeof SealSubscriptions;
declare const index_liquid_SegunoEmailMarketing: typeof SegunoEmailMarketing;
declare const index_liquid_Selleasy: typeof Selleasy;
declare const index_liquid_SeoantTrustBadgesIcon: typeof SeoantTrustBadgesIcon;
declare const index_liquid_ShopPayButton: typeof ShopPayButton;
declare const index_liquid_ShopPayInstallments: typeof ShopPayInstallments;
declare const index_liquid_ShopifyForms: typeof ShopifyForms;
declare const index_liquid_ShopifySubscriptions: typeof ShopifySubscriptions;
declare const index_liquid_SimpleBundlesKits: typeof SimpleBundlesKits;
declare const index_liquid_SkioSubscriptionsYcS20: typeof SkioSubscriptionsYcS20;
declare const index_liquid_SmartSearchBarAndFilters: typeof SmartSearchBarAndFilters;
declare const index_liquid_SproutPlantTreesGrowSales: typeof SproutPlantTreesGrowSales;
declare const index_liquid_Stamped: typeof Stamped;
declare const index_liquid_StellarDeliveryDatePickup: typeof StellarDeliveryDatePickup;
declare const index_liquid_SubifySubscriptionsApp: typeof SubifySubscriptionsApp;
declare const index_liquid_TabItem: typeof TabItem;
declare const index_liquid_TagembedSocialPostReview: typeof TagembedSocialPostReview;
declare const index_liquid_TagshopShoppableVideosUgc: typeof TagshopShoppableVideosUgc;
declare const index_liquid_TeeinblueProductPersonalizer: typeof TeeinblueProductPersonalizer;
declare const index_liquid_ThirdPartySlot: typeof ThirdPartySlot;
declare const index_liquid_TrustBadgesBear: typeof TrustBadgesBear;
declare const index_liquid_TrustMe: typeof TrustMe;
declare const index_liquid_TrustedsiteTrustBadges: typeof TrustedsiteTrustBadges;
declare const index_liquid_Trustoo: typeof Trustoo;
declare const index_liquid_TrustreviewsProductReviews: typeof TrustreviewsProductReviews;
declare const index_liquid_TrustshopProductReviews: typeof TrustshopProductReviews;
declare const index_liquid_UltimateSalesBoost: typeof UltimateSalesBoost;
declare const index_liquid_UnlimitedBundlesDiscounts: typeof UnlimitedBundlesDiscounts;
declare const index_liquid_UppromoteAffiliateMarketing: typeof UppromoteAffiliateMarketing;
declare const index_liquid_Vitals: typeof Vitals;
declare const index_liquid_WcWishlistBackInStock: typeof WcWishlistBackInStock;
declare const index_liquid_WhatmoreShoppableVideosreel: typeof WhatmoreShoppableVideosreel;
declare const index_liquid_WideBundle: typeof WideBundle;
declare const index_liquid_Wiser: typeof Wiser;
declare const index_liquid_WishlistKing: typeof WishlistKing;
declare const index_liquid_WishlistPlus: typeof WishlistPlus;
declare const index_liquid_YotpoReviews: typeof YotpoReviews;
declare namespace index_liquid {
  export {
    Accordion$1 as Accordion,
    index_liquid_AccordionItem as AccordionItem,
    index_liquid_AftershipEmailMarketingsms as AftershipEmailMarketingsms,
    index_liquid_AirProductReviewsAppUgc as AirProductReviewsAppUgc,
    index_liquid_AliReviews as AliReviews,
    index_liquid_AlsoBoughtCbb as AlsoBoughtCbb,
    index_liquid_AovBundlesVolumeDiscounts as AovBundlesVolumeDiscounts,
    index_liquid_AovFreeGiftBuyXGetYBogo as AovFreeGiftBuyXGetYBogo,
    index_liquid_AppointmentBookingCowlendar as AppointmentBookingCowlendar,
    index_liquid_AppstleBundlesDiscounts as AppstleBundlesDiscounts,
    index_liquid_AppstleSubscriptions as AppstleSubscriptions,
    index_liquid_ArticleAuthor as ArticleAuthor,
    index_liquid_ArticleCategory as ArticleCategory,
    index_liquid_ArticleContent as ArticleContent,
    index_liquid_ArticleDate as ArticleDate,
    index_liquid_ArticleExcerpt as ArticleExcerpt,
    index_liquid_ArticleImage as ArticleImage,
    index_liquid_ArticleList as ArticleList,
    ArticlePagination$1 as ArticlePagination,
    ArticleReadMore$1 as ArticleReadMore,
    index_liquid_ArticleTag as ArticleTag,
    index_liquid_ArticleTitle as ArticleTitle,
    index_liquid_BestBuyFulfillment as BestBuyFulfillment,
    index_liquid_BfSizeChartSizeGuide as BfSizeChartSizeGuide,
    index_liquid_BirdChime as BirdChime,
    index_liquid_BloyRewardsProgramLoyalty as BloyRewardsProgramLoyalty,
    index_liquid_Bogos as Bogos,
    index_liquid_BoldProductOptions as BoldProductOptions,
    index_liquid_BoldSubscriptions as BoldSubscriptions,
    index_liquid_BonLoyaltyRewardsReferrals as BonLoyaltyRewardsReferrals,
    index_liquid_BonySubscriptionsApp as BonySubscriptionsApp,
    index_liquid_BoostAISearchDiscovery as BoostAISearchDiscovery,
    index_liquid_Breadcrumb as Breadcrumb,
    index_liquid_Bundler as Bundler,
    Button$1 as Button,
    CSSCode$1 as CSSCode,
    index_liquid_Carousel as Carousel,
    index_liquid_CarouselItem as CarouselItem,
    CarouselItem$1 as CarouselItemV3,
    Carousel$1 as CarouselV3,
    index_liquid_CleanSizeCharts as CleanSizeCharts,
    Column as Col,
    index_liquid_CollectionBanner as CollectionBanner,
    CollectionDescription$1 as CollectionDescription,
    CollectionPaginator$1 as CollectionPaginator,
    index_liquid_CollectionTitle as CollectionTitle,
    CollectionToolbar$1 as CollectionToolbar,
    ContactForm$1 as ContactForm,
    Countdown$1 as Countdown,
    Coupon$1 as Coupon,
    index_liquid_CrossSellCartUpsell as CrossSellCartUpsell,
    index_liquid_CustomProductOptionsVariant as CustomProductOptionsVariant,
    index_liquid_DealeasyVolumeDiscounts as DealeasyVolumeDiscounts,
    Dialog$1 as Dialog,
    index_liquid_DiscountyBulkDiscountSales as DiscountyBulkDiscountSales,
    index_liquid_DynamicCheckout as DynamicCheckout,
    index_liquid_EasifyProductOptions as EasifyProductOptions,
    index_liquid_EasyBundleBuilderSkailama as EasyBundleBuilderSkailama,
    index_liquid_EasySellCOD as EasySellCOD,
    index_liquid_EcoboostifyShoppableReelUgc as EcoboostifyShoppableReelUgc,
    index_liquid_EcomsendBackInStockAlert as EcomsendBackInStockAlert,
    index_liquid_EssentPreorderBackInStock as EssentPreorderBackInStock,
    index_liquid_EssentialAnnouncementBar as EssentialAnnouncementBar,
    index_liquid_EssentialCountdownTimerBar as EssentialCountdownTimerBar,
    EstimateDate$1 as EstimateDate,
    index_liquid_EstimatedDeliveryDatePlus as EstimatedDeliveryDatePlus,
    index_liquid_FastBundleBundlesDiscounts as FastBundleBundlesDiscounts,
    index_liquid_FeraReviews as FeraReviews,
    FileUpload$1 as FileUpload,
    index_liquid_FirePush as FirePush,
    index_liquid_FlyBundlesUpsellsFbt as FlyBundlesUpsellsFbt,
    index_liquid_FordeerProductLabels as FordeerProductLabels,
    FromCheckbox as FormCheckbox,
    FormDropdown$1 as FormDropdown,
    FormEmail$1 as FormEmail,
    FormTextarea$1 as FormTextarea,
    index_liquid_FrequentlyBoughtTogether as FrequentlyBoughtTogether,
    index_liquid_GloColorSwatchvariantImage as GloColorSwatchvariantImage,
    index_liquid_GloboProductOptionsVariant as GloboProductOptionsVariant,
    index_liquid_GoogleReviewsByReputon as GoogleReviewsByReputon,
    index_liquid_Growave as Growave,
    index_liquid_GrowthSuiteDiscountCodes as GrowthSuiteDiscountCodes,
    Heading$1 as Heading,
    HeroBanner$1 as HeroBanner,
    index_liquid_HextomCountdownTimerBar as HextomCountdownTimerBar,
    index_liquid_HextomFreeShippingBar as HextomFreeShippingBar,
    index_liquid_HulkFormBuilder as HulkFormBuilder,
    index_liquid_HulkProductOptions as HulkProductOptions,
    index_liquid_Icon as Icon,
    IconList$1 as IconList,
    index_liquid_IconListHoz as IconListHoz,
    index_liquid_IconListItem as IconListItem,
    IconListIHozItemLiquid as IconListItemHoz,
    IconListV2$1 as IconListV2,
    Image$1 as Image,
    ImageComparison$1 as ImageComparison,
    index_liquid_InfiniteOptions as InfiniteOptions,
    index_liquid_Instafeed as Instafeed,
    index_liquid_InstasellShoppableInstagram as InstasellShoppableInstagram,
    index_liquid_JudgemeReviews as JudgemeReviews,
    index_liquid_JunipProductReviewsUgc as JunipProductReviewsUgc,
    index_liquid_KachingBundles as KachingBundles,
    index_liquid_KachingSubscriptionsApp as KachingSubscriptionsApp,
    index_liquid_KingProductOptions as KingProductOptions,
    index_liquid_KiteFreeGiftDiscount as KiteFreeGiftDiscount,
    index_liquid_KlarnaMessaging as KlarnaMessaging,
    index_liquid_Klaviyo as Klaviyo,
    index_liquid_KoalaBundleQuantityDiscount as KoalaBundleQuantityDiscount,
    index_liquid_LaiProductReviews as LaiProductReviews,
    index_liquid_Line as Line,
    index_liquid_LoloyalLoyaltyReferrals as LoloyalLoyaltyReferrals,
    index_liquid_LoopSubscriptions as LoopSubscriptions,
    index_liquid_LooxReviews as LooxReviews,
    index_liquid_Marquee as Marquee,
    index_liquid_MarqueeItem as MarqueeItem,
    index_liquid_MaxbundleProductBundles as MaxbundleProductBundles,
    index_liquid_MbcBundleVolumeDiscount as MbcBundleVolumeDiscount,
    index_liquid_MyappgurusProductReviews as MyappgurusProductReviews,
    Newsletter$1 as Newsletter,
    index_liquid_NotifyBackInStockPreOrder as NotifyBackInStockPreOrder,
    index_liquid_OkendoReviewsLoyalty as OkendoReviewsLoyalty,
    index_liquid_Omnisend as Omnisend,
    index_liquid_Opinew as Opinew,
    index_liquid_ParcelPanel as ParcelPanel,
    index_liquid_PickyStory as PickyStory,
    index_liquid_PowerfulContactFormBuilder as PowerfulContactFormBuilder,
    index_liquid_PreorderNowPreOrderPq as PreorderNowPreOrderPq,
    index_liquid_PreorderNowWodPresale as PreorderNowWodPresale,
    index_liquid_Product as Product,
    ProductBadge$1 as ProductBadge,
    index_liquid_ProductBundleDiscount as ProductBundleDiscount,
    index_liquid_ProductBundleDiscountItem as ProductBundleDiscountItem,
    ProductButton$1 as ProductButton,
    ProductDescription$1 as ProductDescription,
    ProductImages$2 as ProductImages,
    ProductImages$1 as ProductImagesV2,
    ProductImages as ProductImagesV3,
    index_liquid_ProductList as ProductList,
    ProductList$1 as ProductListV3,
    index_liquid_ProductOptionsCustomizer as ProductOptionsCustomizer,
    index_liquid_ProductOptionsVariantOption as ProductOptionsVariantOption,
    index_liquid_ProductPrice as ProductPrice,
    ProductProperties$1 as ProductProperties,
    index_liquid_ProductQuantity as ProductQuantity,
    index_liquid_ProductReviews as ProductReviews,
    index_liquid_ProductSku as ProductSku,
    ProductTag$1 as ProductTag,
    index_liquid_ProductTitle as ProductTitle,
    index_liquid_ProductVariants as ProductVariants,
    index_liquid_ProductVendor as ProductVendor,
    ProductViewMore$1 as ProductViewMore,
    index_liquid_PumperBundlesVolumeDiscount as PumperBundlesVolumeDiscount,
    index_liquid_PushOwl as PushOwl,
    index_liquid_QikifyUpsell as QikifyUpsell,
    index_liquid_RapiBundleQuantityBreaks as RapiBundleQuantityBreaks,
    index_liquid_RechargeSubscriptions as RechargeSubscriptions,
    index_liquid_RecurpaySubscriptionApp as RecurpaySubscriptionApp,
    index_liquid_Releasit as Releasit,
    index_liquid_RequestQuoteHidePrice as RequestQuoteHidePrice,
    index_liquid_ReviewxpoProductReviewsApp as ReviewxpoProductReviewsApp,
    index_liquid_Rivyo as Rivyo,
    index_liquid_Root as Root,
    Row$1 as Row,
    index_liquid_Ryviu as Ryviu,
    index_liquid_SealSubscriptions as SealSubscriptions,
    Section$1 as Section,
    index_liquid_SegunoEmailMarketing as SegunoEmailMarketing,
    index_liquid_Selleasy as Selleasy,
    index_liquid_SeoantTrustBadgesIcon as SeoantTrustBadgesIcon,
    index_liquid_ShopPayButton as ShopPayButton,
    index_liquid_ShopPayInstallments as ShopPayInstallments,
    index_liquid_ShopifyForms as ShopifyForms,
    index_liquid_ShopifySubscriptions as ShopifySubscriptions,
    index_liquid_SimpleBundlesKits as SimpleBundlesKits,
    index_liquid_SkioSubscriptionsYcS20 as SkioSubscriptionsYcS20,
    index_liquid_SmartSearchBarAndFilters as SmartSearchBarAndFilters,
    index_liquid_SproutPlantTreesGrowSales as SproutPlantTreesGrowSales,
    index_liquid_Stamped as Stamped,
    index_liquid_StellarDeliveryDatePickup as StellarDeliveryDatePickup,
    Sticky$1 as Sticky,
    StockCounter$1 as StockCounter,
    index_liquid_SubifySubscriptionsApp as SubifySubscriptionsApp,
    SubmitButton$1 as SubmitButton,
    index_liquid_TabItem as TabItem,
    Tabs$1 as Tabs,
    index_liquid_TagembedSocialPostReview as TagembedSocialPostReview,
    index_liquid_TagshopShoppableVideosUgc as TagshopShoppableVideosUgc,
    index_liquid_TeeinblueProductPersonalizer as TeeinblueProductPersonalizer,
    Text$1 as Text,
    TextField$1 as TextField,
    TextInput$1 as TextInput,
    index_liquid_ThirdPartySlot as ThirdPartySlot,
    index_liquid_TrustBadgesBear as TrustBadgesBear,
    index_liquid_TrustMe as TrustMe,
    index_liquid_TrustedsiteTrustBadges as TrustedsiteTrustBadges,
    index_liquid_Trustoo as Trustoo,
    index_liquid_TrustreviewsProductReviews as TrustreviewsProductReviews,
    index_liquid_TrustshopProductReviews as TrustshopProductReviews,
    index_liquid_UltimateSalesBoost as UltimateSalesBoost,
    index_liquid_UnlimitedBundlesDiscounts as UnlimitedBundlesDiscounts,
    index_liquid_UppromoteAffiliateMarketing as UppromoteAffiliateMarketing,
    Video$1 as Video,
    index_liquid_Vitals as Vitals,
    index_liquid_WcWishlistBackInStock as WcWishlistBackInStock,
    index_liquid_WhatmoreShoppableVideosreel as WhatmoreShoppableVideosreel,
    index_liquid_WideBundle as WideBundle,
    index_liquid_Wiser as Wiser,
    index_liquid_WishlistKing as WishlistKing,
    index_liquid_WishlistPlus as WishlistPlus,
    index_liquid_YotpoReviews as YotpoReviews,
    config as videoSetting,
  };
}

declare const _default$2: {
    EssentPreorderBackInStock: React.FC<EssentPreorderBackInStockProps>;
    WcWishlistBackInStock: React.FC<WcWishlistBackInStockProps>;
    BonySubscriptionsApp: React.FC<BonySubscriptionsAppProps>;
    GrowthSuiteDiscountCodes: React.FC<GrowthSuiteDiscountCodesProps>;
    KachingSubscriptionsApp: React.FC<KachingSubscriptionsAppProps>;
    BloyRewardsProgramLoyalty: React.FC<BloyRewardsProgramLoyaltyProps>;
    DealeasyVolumeDiscounts: React.FC<DealeasyVolumeDiscountsProps>;
    UppromoteAffiliateMarketing: React.FC<UppromoteAffiliateMarketingProps>;
    AovBundlesVolumeDiscounts: React.FC<AovBundlesVolumeDiscountsProps>;
    AovFreeGiftBuyXGetYBogo: React.FC<AovFreeGiftBuyXGetYBogoProps>;
    EcomsendBackInStockAlert: React.FC<EcomsendBackInStockAlertProps>;
    AppstleBundlesDiscounts: React.FC<AppstleBundlesDiscountsProps>;
    Accordion: React.FC<AccordionProps>;
    AccordionItem: React.FC<AccordionItemProps>;
    ArticleList: React.FC<ArticleListProps>;
    ArticleTitle: React.FC<ArticleTitleProps>;
    ArticleExcerpt: React.FC<ArticleExcerptProps>;
    ArticleContent: React.FC<ArticleContentProps>;
    ArticleImage: React.FC<ArticleImageProps>;
    ArticlePagination: React.FC<CollectionPaginatorProps>;
    ArticleAuthor: React.FC<ArticleAuthorProps>;
    ArticleTag: React.FC<ArticleTagProps>;
    ArticleCategory: React.FC<ArticleCategoryProps>;
    ArticleDate: React.FC<ArticleDateProps>;
    ArticleReadMore: React.FC<ArticleReadMoreProps>;
    HeroBanner: React.FC<HeroBannerProps>;
    Breadcrumb: React.FC<BreadcrumbProps>;
    Button: React.FC<ButtonProps>;
    CarouselV3: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<CarouselSettingProps$1, CarouselStyleProps$1, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        onSwiperReady?: (swiper: _gem_sdk_swiper.default) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
        isDisableResetSlide?: boolean;
        isProductList?: boolean;
        thumbsSwiper?: string;
        productBadgeLiquid?: string;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
        isEnableCheckHasScrollableContent?: boolean;
    } & React.RefAttributes<CarouselRef$1>>;
    CarouselItemV3: React.FC<CarouselItemProps$1>;
    Carousel: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<CarouselSettingProps, CarouselStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & {
        children?: React.ReactNode;
        moveToIdx?: number;
        isHiddenArrowWhenDisabled?: boolean;
        hiddenDotWhenOnlyOne?: boolean;
        disableMarginAuto?: boolean;
        onLoaded?: (status: boolean) => void;
        onChangeActive?: (index: number) => void;
        onUpdated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onCreated?: (slider: _gem_sdk_keen_slider.KeenSliderInstance) => void;
        onClickArrow?: () => void;
        onHandleChangeSlideByInteraction?: (index: number) => void;
        elmRef?: React.Ref<HTMLDivElement>;
        rootClass?: string;
        parentClass?: string;
        rootAttrs?: Record<string, string | boolean | number>;
        slidesClass?: string;
        fullHeight?: boolean;
    } & {
        rootId?: string;
        rootClass?: string;
        wrapperClass?: string;
        rootStyles?: React.CSSProperties;
        rawChildren?: any[];
        advanced?: any;
        disableMarginAuto?: boolean;
        slidesClass?: string;
        conditionAppendJs?: string;
    } & React.RefAttributes<CarouselRef>>;
    CarouselItem: React.FC<CarouselItemProps>;
    Cart: React.FC<CartProps>;
    CartList: React.FC<CartListProps>;
    CartLinePrice: React.FC<CartLinePriceProps>;
    CartLineVariant: React.FC<CartLineVariantProps>;
    CartLineImage: React.FC<CartLineImageProps>;
    CartTotalPrice: React.FC<CartTotalPriceProps>;
    CartTotalItem: React.FC<CartTotalItemProps>;
    CartCheckout: React.FC<CartCheckoutProps>;
    DiscountInput: React.FC<DiscountInputProps>;
    CartDiscount: React.FC<CartDiscountProps>;
    CartOrderNote: React.FC<CartOrderNoteProps>;
    CartLineAttribute: React.FC<CartLineAttributeProps>;
    CouponList: React.FC<{}>;
    ShopPayButton: React.FC<ShopPayButtonProps>;
    CheckoutNow: React.FC<CheckoutNowProps>;
    CSSCode: ({ setting, style, advanced, builderAttrs, builderProps, children, pageContext, }: CSSCodeProps) => React.JSX.Element;
    CollectionTitle: React.FC<CollectionTitleProps>;
    CollectionDescription: React.FC<CollectionDescriptionProps>;
    CollectionBanner: React.FC<CollectionBannerProps>;
    CollectionToolbar: React.FC<CollectionToolbarProps>;
    CollectionPaginator: React.FC<CollectionPaginatorProps>;
    Countdown: React.FC<CountdownProps>;
    Coupon: React.FC<CouponProps>;
    Dialog: (props: DialogProps$1) => React.JSX.Element;
    EstimateDate: React.FC<EstimateDateProps>;
    Newsletter: ({ children, setting, styles, style, builderAttrs, builderProps, }: NewsletterProps) => React.JSX.Element;
    ContactForm: ({ children, styles, setting, style, builderAttrs, builderProps, }: NewsletterProps) => React.JSX.Element;
    FormEmail: ({ builderProps, builderAttrs, setting, advanced, children, styles, }: FormEmailProps) => React.JSX.Element;
    SubmitButton: ({ setting, builderProps, builderAttrs, style, styles, advanced, children, }: SubmitButtonProps) => React.JSX.Element;
    TextField: React.FC<TextFieldProps>;
    TextInput: React.FC<TextInputProps>;
    FormTextarea: React.FC<TextAreaProps>;
    FormDropdown: ({ builderProps, builderAttrs, setting, advanced, children, styles, }: FormDropdownProps) => React.JSX.Element;
    FormCheckbox: ({ builderProps, setting, advanced, styles }: FormCheckboxProps) => React.JSX.Element;
    Root: React.FC<{
        children?: React.ReactNode;
    }>;
    Section: React.FC<RowProps>;
    Row: React.FC<RowProps>;
    Col: React.FC<ColProps>;
    Header: ({ builderAttrs, builderProps, style, setting, styles, children }: HeaderProps) => React.JSX.Element | null;
    BasicHeader: ({ btnBgColor, btnBorder, btnRounded, btnSpacing, btnTextColor, btnTypography, btnType, btnWidth, openMode, buyNow, breakpoint, ...props }: HeaderCommonProps) => React.JSX.Element;
    ModernHeader: (props: HeaderCommonProps) => React.JSX.Element;
    MobileMenu: ({ menu, typography, typo, arrow, menuTextColor, menuBg, textColor, className, itemEnableHoverEffect, }: Pick<HeaderCommonProps, "menu" | "textColor" | "typography" | "height" | "arrow" | "typo" | "menuTextColor" | "menuBg" | "itemEnableHoverEffect"> & {
        className?: string;
    }) => React.JSX.Element;
    DesktopMenu: ({ menu, height, arrow, textColor, menuTextColor, typography, typo, headerBg, menuBg, className, itemEnableHoverEffect, enableDropdownHoverEffect, }: Pick<HeaderCommonProps, "menu" | "textColor" | "typography" | "height" | "arrow" | "typo" | "menuTextColor" | "menuBg" | "headerBg" | "itemEnableHoverEffect" | "enableDropdownHoverEffect"> & {
        className?: string;
    }) => React.JSX.Element;
    Heading: React.FC<HeadingProps>;
    Icon: React.FC<IconProps>;
    IconList: React.FC<IconListProps$1>;
    IconListItem: React.FC<IconListItemProps$1>;
    IconListHoz: React.FC<IconListHozProps>;
    IconListItemHoz: React.FC<IconListItemProps>;
    IconListV2: React.FC<IconListProps>;
    Image: React.FC<ImageProps>;
    ImageComparison: React.FC<ImageComparisonProps>;
    ImageDetection: React.FC<ImageDetectionProps>;
    Input: React.FC<InputProps>;
    Line: React.FC<LineProps>;
    Link: React.FC<LinkProps>;
    Marquee: ({ children, style, builderAttrs, advanced, ...props }: MarqueeProps) => React.JSX.Element;
    MarqueeItem: React.NamedExoticComponent<MarqueeItemProps>;
    Menu: React.FC<MenuProps>;
    Modal: React.FC<ModalProps>;
    Pagination: React.FC<PaginationProps>;
    PostPurchaseAdvancedList: React.FC<PostPurchaseAdvancedListProps>;
    PostPurchaseAdvancedListItem: React.FC<PostPurchaseAdvancedListItemProps>;
    PostPurchaseAcceptButton: (props: PostPurchaseButtonProps) => React.JSX.Element;
    PostPurchaseButton: ({ styles, builderAttrs, style, setting, advanced, builderProps, disabled, ...props }: PostPurchaseButtonProps & {
        disabled: boolean;
    }) => React.JSX.Element;
    PostPurchaseCalloutBox: (props: CalloutBoxProps) => React.JSX.Element;
    PostPurchaseCalloutText: ({ setting, styles, style, builderAttrs, builderProps, children, }: CalloutTextProps) => React.JSX.Element;
    PostPurchaseCountdownTimer: React.FC<{}>;
    PostPurchaseImage: React.FC<PostPurchaseImageProps>;
    PostPurchaseLine: React.FC<PostPurchaseLineProps>;
    PostPurchaseLink: React.FC<PostPurchaseLinkProps>;
    PostPurchaseHeading: ({ styles, builderAttrs, style, setting, advanced, builderProps, className, children, textClassWrapper, textClass, ...props }: PostPurchaseTextProps) => React.JSX.Element;
    PostPurchaseText: ({ styles, builderAttrs, style, setting, advanced, builderProps, className, children, textClassWrapper, textClass, ...props }: PostPurchaseTextProps) => React.JSX.Element;
    PostPurchaseProductTitle: React.FC<PostPurchaseProductTitleProps>;
    PostPurchaseProductDescription: React.FC<PostPurchaseProductDescriptionProps>;
    PostPurchaseProductPrice: React.FC<PostPurchaseProductPriceProps>;
    PostPurchaseProductVariants: React.FC<PostPurchaseProductVariantsProps>;
    PostPurchaseProductQuantity: React.FC<PostPurchaseProductQuantityProps>;
    PostPurchaseProductPriceBreakdown: React.FC<PostPurchaseProductPriceBreakdownProps>;
    PostPurchaseProductOffer: React.FC<PostPurchaseProductOfferProps>;
    PostPurchaseProductDiscountTag: React.FC<PostPurchaseProductDiscountTagProps>;
    PostPurchaseProductImages: (props: PostPurchaseProductImagesProps) => React.JSX.Element;
    PostPurchaseProductSubscription: React.FC<PostPurchaseProductSubscriptionProps>;
    PostPurchaseBuyerConsent: React.FC<PostPurchaseBuyerConsentProps>;
    EstimatedDeliveryDatePlus: React.FC<EstimatedDeliveryDatePlusProps>;
    OkendoReviewsLoyalty: React.FC<OkendoReviewsLoyaltyProps>;
    EssentialAnnouncementBar: React.FC<EssentialAnnouncementBarProps>;
    EssentialCountdownTimerBar: React.FC<EssentialCountdownTimerBarProps>;
    StellarDeliveryDatePickup: React.FC<StellarDeliveryDatePickupProps>;
    TrustshopProductReviews: React.FC<TrustshopProductReviewsProps>;
    HulkProductOptions: React.FC<HulkProductOptionsProps>;
    MyappgurusProductReviews: React.FC<MyappgurusProductReviewsProps>;
    TrustreviewsProductReviews: React.FC<TrustreviewsProductReviewsProps>;
    DiscountyBulkDiscountSales: React.FC<DiscountyBulkDiscountSalesProps>;
    SeoantTrustBadgesIcon: React.FC<SeoantTrustBadgesIconProps>;
    SegunoEmailMarketing: React.FC<SegunoEmailMarketingProps>;
    AftershipEmailMarketingsms: React.FC<AftershipEmailMarketingsmsProps>;
    BestBuyFulfillment: React.FC<BestBuyFulfillmentProps>;
    ProductOptionsVariantOption: React.FC<ProductOptionsVariantOptionProps>;
    GloboProductOptionsVariant: React.FC<GloboProductOptionsVariantProps>;
    TeeinblueProductPersonalizer: React.FC<TeeinblueProductPersonalizerProps>;
    HulkFormBuilder: React.FC<HulkFormBuilderProps>;
    LoloyalLoyaltyReferrals: React.FC<LoloyalLoyaltyReferralsProps>;
    PowerfulContactFormBuilder: React.FC<PowerfulContactFormBuilderProps>;
    WishlistKing: React.FC<WishlistKingProps>;
    WishlistPlus: React.FC<WishlistPlusProps>;
    InstasellShoppableInstagram: React.FC<InstasellShoppableInstagramProps>;
    SproutPlantTreesGrowSales: React.FC<SproutPlantTreesGrowSalesProps>;
    RapiBundleQuantityBreaks: React.FC<RapiBundleQuantityBreaksProps>;
    AppointmentBookingCowlendar: React.FC<AppointmentBookingCowlendarProps>;
    GoogleReviewsByReputon: React.FC<GoogleReviewsByReputonProps>;
    MbcBundleVolumeDiscount: React.FC<MbcBundleVolumeDiscountProps>;
    ProductOptionsCustomizer: React.FC<ProductOptionsCustomizerProps>;
    AirProductReviewsAppUgc: React.FC<AirProductReviewsAppUgcProps>;
    TagembedSocialPostReview: React.FC<TagembedSocialPostReviewProps>;
    WhatmoreShoppableVideosreel: React.FC<WhatmoreShoppableVideosreelProps>;
    TagshopShoppableVideosUgc: React.FC<TagshopShoppableVideosUgcProps>;
    JunipProductReviewsUgc: React.FC<JunipProductReviewsUgcProps>;
    FlyBundlesUpsellsFbt: React.FC<FlyBundlesUpsellsFbtProps>;
    PreorderNowWodPresale: React.FC<PreorderNowWodPresaleProps>;
    PreorderNowPreOrderPq: React.FC<PreorderNowPreOrderPqProps>;
    MaxbundleProductBundles: React.FC<MaxbundleProductBundlesProps>;
    KoalaBundleQuantityDiscount: React.FC<KoalaBundleQuantityDiscountProps>;
    EasyBundleBuilderSkailama: React.FC<EasyBundleBuilderSkailamaProps>;
    FastBundleBundlesDiscounts: React.FC<FastBundleBundlesDiscountsProps>;
    KiteFreeGiftDiscount: React.FC<KiteFreeGiftDiscountProps>;
    UnlimitedBundlesDiscounts: React.FC<UnlimitedBundlesDiscountsProps>;
    SimpleBundlesKits: React.FC<SimpleBundlesKitsProps>;
    ReviewxpoProductReviewsApp: React.FC<ReviewxpoProductReviewsAppProps>;
    PumperBundlesVolumeDiscount: React.FC<PumperBundlesVolumeDiscountProps>;
    NotifyBackInStockPreOrder: React.FC<NotifyBackInStockPreOrderProps>;
    ShopifyForms: React.FC<ShopifyFormsProps>;
    SkioSubscriptionsYcS20: React.FC<SkioSubscriptionsYcS20Props>;
    LoopSubscriptions: React.FC<LoopSubscriptionsProps>;
    Selleasy: React.FC<SelleasyProps>;
    RecurpaySubscriptionApp: React.FC<RecurpaySubscriptionAppProps>;
    SubifySubscriptionsApp: React.FC<SubifySubscriptionsAppProps>;
    ShopifySubscriptions: React.FC<ShopifySubscriptionsProps>;
    BonLoyaltyRewardsReferrals: React.FC<BonLoyaltyRewardsReferralsProps>;
    EasifyProductOptions: React.FC<EasifyProductOptionsProps>;
    CustomProductOptionsVariant: React.FC<CustomProductOptionsVariantProps>;
    KlarnaMessaging: React.FC<KlarnaMessagingProps>;
    FordeerProductLabels: React.FC<FordeerProductLabelsProps>;
    RechargeSubscriptions: React.FC<RechargeSubscriptionsProps>;
    Product: React.FC<ProductProps>;
    ProductTitle: React.FC<ProductTitleProps>;
    ProductQuantity: React.FC<ProductQuantityProps>;
    ProductPrice: React.FC<ProductPriceProps>;
    ProductSku: React.FC<SkuProps>;
    FileUpload: React.FC<FileUploadProps>;
    ProductBundleDiscount: React.FC<ProductBundleDiscountProps>;
    ProductBundleDiscountItem: React.FC<{
        children?: React.ReactNode;
    }>;
    ProductButton: React.FC<ProductButtonProps>;
    ProductDescription: React.FC<ProductDescriptionProps>;
    ProductVariants: React.FC<ProductVariantsProps>;
    ProductImages: React.FC<ProductImagesProps>;
    ProductImagesV3: React.FC<ProductImagesProps$2>;
    ProductImagesV2: React.FC<ProductImagesProps$1>;
    ProductProperties: React.FC<ProductPropertiesProps>;
    ProductQuickView: () => React.JSX.Element | null;
    ProductTag: React.FC<ProductTagProps>;
    ProductListV3: React.FC<ProductListProps$1>;
    ProductList: React.FC<ProductListProps>;
    Radio: React.FC<RadioProps>;
    Select: React.FC<SelectProps>;
    Tabs: (props: TabsProps) => React.JSX.Element;
    TabItem: React.FC<TabItemProps>;
    Text: React.ForwardRefExoticComponent<_gem_sdk_core.BaseProps<TextSettingProps, TextStyleProps, Record<string, any>> & {
        builderAttrs?: Record<string, any>;
        style?: React.CSSProperties;
    } & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, ""> & {
        disableEdit?: boolean;
        pageContext?: _gem_sdk_core.PageContext;
    } & React.RefAttributes<HTMLElement>>;
    Textarea: React.FC<TextareaProps>;
    Video: React.FC<VideoProps>;
    PushOwl: React.FC<ButtonProps>;
    ThirdPartySlot: React.FC<AnyShopifyAppsProps>;
    ShopPayInstallments: React.FC<ShopPayInstallmentProps>;
    JudgemeReviews: React.FC<JudgemeReviewsProps>;
    LooxReviews: React.FC<LooxReviewsProps>;
    Instafeed: React.FC<InstafeedProps>;
    Klaviyo: React.FC<KlaviyoProps>;
    YotpoLoyalty: React.FC<YotpoLoyaltyProps>;
    SmartSearchBarAndFilters: React.FC<SmartSearchBarAndFiltersProps>;
    ProductReviews: React.FC<ProductReviewsProps>;
    Ryviu: React.FC<RyviuProps>;
    Rivyo: React.FC<RivyoProps>;
    Vitals: React.FC<VitalsProps>;
    Omnisend: React.FC<OmnisendProps>;
    ParcelPanel: React.FC<ParcelPanelProps>;
    TrustMe: React.FC<TrustMeProps>;
    Trustoo: React.FC<TrustooProps>;
    SealSubscriptions: React.FC<SealSubscriptionsProps>;
    AppstleSubscriptions: React.FC<AppstleSubscriptionsProps>;
    FeraReviews: React.FC<FeraReviewsProps>;
    Growave: React.FC<GrowaveProps>;
    KachingBundles: React.FC<KachingBundlesProps>;
    Bogos: React.FC<BogosProps>;
    Opinew: React.FC<OpinewProps>;
    UltimateSalesBoost: React.FC<UltimateSalesBoostProps>;
    FirePush: React.FC<FirePushProps>;
    FrequentlyBoughtTogether: React.FC<FrequentlyBoughtTogetherProps>;
    BoldSubscriptions: React.FC<BoldSubscriptionsProps>;
    BoldProductOptions: React.FC<BoldProductOptionsProps>;
    WideBundle: React.FC<WideBundleProps>;
    PickyStory: React.FC<PickyStoryProps>;
    InfiniteOptions: React.FC<InfiniteOptionsProps>;
    Wiser: React.FC<WiserProps>;
    Stamped: React.FC<StampedProps>;
    Bundler: React.FC<BundlerProps>;
    LaiProductReviews: React.FC<LaiProductReviewsProps>;
    CrossSellCartUpsell: React.FC<CrossSellCartUpsellProps>;
    BoostAISearchDiscovery: React.FC<BoostAISearchDiscoveryProps>;
    YotpoReviews: React.FC<YotpoReviewsProps>;
    AliReviews: React.FC<AliReviewsProps>;
    CleanSizeCharts: React.FC<CleanSizeChartsProps>;
    QikifyUpsell: React.FC<QikifyUpsellProps>;
    EasySellCOD: React.FC<EasySellCODProps>;
    RequestQuoteHidePrice: React.FC<RequestQuoteHidePriceProps>;
    InstantJudgemeReviews: React.FC<InstantJudgemeReviewsProps>;
    InstantLooxReviews: React.FC<InstantLooxReviewsProps>;
    InstantKlaviyo: React.FC<InstantKlaviyoProps>;
    InstantYotpoLoyalty: React.FC<InstantYotpoLoyaltyProps>;
    Releasit: React.FC<ReleasitProps>;
    BirdChime: React.FC<BirdChimeProps>;
    StockCounter: React.FC<StockCounterProps>;
    DynamicCheckout: React.FC<DynamicCheckoutProps>;
    Sticky: React.FC<StickyProps>;
    ProductVendor: React.FC<VendorProps>;
    KingProductOptions: React.FC<KingProductOptionsProps>;
    ProductViewMore: ({ style, styles, setting, advanced, builderProps, builderAttrs, children, }: ProductViewMoreProps) => React.JSX.Element;
    ProductBadge: React.FC<ProductBadgeProps>;
    HextomCountdownTimerBar: React.FC<HextomCountdownTimerBarProps>;
    TrustBadgesBear: React.FC<TrustBadgesBearProps>;
    TrustedsiteTrustBadges: React.FC<TrustedsiteTrustBadgesProps>;
    GloColorSwatchvariantImage: React.FC<GloColorSwatchvariantImageProps>;
    BfSizeChartSizeGuide: React.FC<BfSizeChartSizeGuideProps>;
    AlsoBoughtCbb: React.FC<AlsoBoughtCbbProps>;
    HextomFreeShippingBar: React.FC<HextomFreeShippingBarProps>;
    EcoboostifyShoppableReelUgc: React.FC<EcoboostifyShoppableReelUgcProps>;
};

declare const _default$1: {
    Sticky: _gem_sdk_core.ComponentSetting<StickyProps>;
    ShopPayInstallments: _gem_sdk_core.ComponentSetting<ShopPayInstallmentProps>;
    ThirdPartySlot: _gem_sdk_core.ComponentSetting<AnyShopifyAppsProps>;
    StockCounter: _gem_sdk_core.ComponentSetting<StockCounterProps>;
    InstantJudgemeReviews: _gem_sdk_core.ComponentSetting<InstantJudgemeReviewsProps>;
    InstantLooxReviews: _gem_sdk_core.ComponentSetting<InstantLooxReviewsProps>;
    InstantKlaviyo: _gem_sdk_core.ComponentSetting<InstantKlaviyoProps>;
    InstantYotpoLoyalty: _gem_sdk_core.ComponentSetting<InstantYotpoLoyaltyProps>;
    EstimatedDeliveryDatePlus: _gem_sdk_core.ComponentSetting<EstimatedDeliveryDatePlusProps>;
    OkendoReviewsLoyalty: _gem_sdk_core.ComponentSetting<OkendoReviewsLoyaltyProps>;
    EssentialAnnouncementBar: _gem_sdk_core.ComponentSetting<EssentialAnnouncementBarProps>;
    EssentialCountdownTimerBar: _gem_sdk_core.ComponentSetting<EssentialCountdownTimerBarProps>;
    StellarDeliveryDatePickup: _gem_sdk_core.ComponentSetting<StellarDeliveryDatePickupProps>;
    TrustshopProductReviews: _gem_sdk_core.ComponentSetting<TrustshopProductReviewsProps>;
    HulkProductOptions: _gem_sdk_core.ComponentSetting<HulkProductOptionsProps>;
    MyappgurusProductReviews: _gem_sdk_core.ComponentSetting<MyappgurusProductReviewsProps>;
    TrustreviewsProductReviews: _gem_sdk_core.ComponentSetting<TrustreviewsProductReviewsProps>;
    DiscountyBulkDiscountSales: _gem_sdk_core.ComponentSetting<DiscountyBulkDiscountSalesProps>;
    SeoantTrustBadgesIcon: _gem_sdk_core.ComponentSetting<SeoantTrustBadgesIconProps>;
    SegunoEmailMarketing: _gem_sdk_core.ComponentSetting<SegunoEmailMarketingProps>;
    AftershipEmailMarketingsms: _gem_sdk_core.ComponentSetting<AftershipEmailMarketingsmsProps>;
    BestBuyFulfillment: _gem_sdk_core.ComponentSetting<BestBuyFulfillmentProps>;
    ProductOptionsVariantOption: _gem_sdk_core.ComponentSetting<ProductOptionsVariantOptionProps>;
    GloboProductOptionsVariant: _gem_sdk_core.ComponentSetting<GloboProductOptionsVariantProps>;
    TeeinblueProductPersonalizer: _gem_sdk_core.ComponentSetting<TeeinblueProductPersonalizerProps>;
    WishlistKing: _gem_sdk_core.ComponentSetting<WishlistKingProps>;
    HulkFormBuilder: _gem_sdk_core.ComponentSetting<HulkFormBuilderProps>;
    LoloyalLoyaltyReferrals: _gem_sdk_core.ComponentSetting<LoloyalLoyaltyReferralsProps>;
    PowerfulContactFormBuilder: _gem_sdk_core.ComponentSetting<PowerfulContactFormBuilderProps>;
    WishlistPlus: _gem_sdk_core.ComponentSetting<WishlistPlusProps>;
    InstasellShoppableInstagram: _gem_sdk_core.ComponentSetting<InstasellShoppableInstagramProps>;
    SproutPlantTreesGrowSales: _gem_sdk_core.ComponentSetting<SproutPlantTreesGrowSalesProps>;
    RapiBundleQuantityBreaks: _gem_sdk_core.ComponentSetting<RapiBundleQuantityBreaksProps>;
    AppointmentBookingCowlendar: _gem_sdk_core.ComponentSetting<AppointmentBookingCowlendarProps>;
    GoogleReviewsByReputon: _gem_sdk_core.ComponentSetting<GoogleReviewsByReputonProps>;
    MbcBundleVolumeDiscount: _gem_sdk_core.ComponentSetting<MbcBundleVolumeDiscountProps>;
    ProductOptionsCustomizer: _gem_sdk_core.ComponentSetting<ProductOptionsCustomizerProps>;
    AirProductReviewsAppUgc: _gem_sdk_core.ComponentSetting<AirProductReviewsAppUgcProps>;
    TagembedSocialPostReview: _gem_sdk_core.ComponentSetting<TagembedSocialPostReviewProps>;
    WhatmoreShoppableVideosreel: _gem_sdk_core.ComponentSetting<WhatmoreShoppableVideosreelProps>;
    TagshopShoppableVideosUgc: _gem_sdk_core.ComponentSetting<TagshopShoppableVideosUgcProps>;
    JunipProductReviewsUgc: _gem_sdk_core.ComponentSetting<JunipProductReviewsUgcProps>;
    FlyBundlesUpsellsFbt: _gem_sdk_core.ComponentSetting<FlyBundlesUpsellsFbtProps>;
    PreorderNowWodPresale: _gem_sdk_core.ComponentSetting<PreorderNowWodPresaleProps>;
    PreorderNowPreOrderPq: _gem_sdk_core.ComponentSetting<PreorderNowPreOrderPqProps>;
    MaxbundleProductBundles: _gem_sdk_core.ComponentSetting<MaxbundleProductBundlesProps>;
    KoalaBundleQuantityDiscount: _gem_sdk_core.ComponentSetting<KoalaBundleQuantityDiscountProps>;
    EasyBundleBuilderSkailama: _gem_sdk_core.ComponentSetting<EasyBundleBuilderSkailamaProps>;
    FastBundleBundlesDiscounts: _gem_sdk_core.ComponentSetting<FastBundleBundlesDiscountsProps>;
    KiteFreeGiftDiscount: _gem_sdk_core.ComponentSetting<KiteFreeGiftDiscountProps>;
    UnlimitedBundlesDiscounts: _gem_sdk_core.ComponentSetting<UnlimitedBundlesDiscountsProps>;
    SimpleBundlesKits: _gem_sdk_core.ComponentSetting<SimpleBundlesKitsProps>;
    ReviewxpoProductReviewsApp: _gem_sdk_core.ComponentSetting<ReviewxpoProductReviewsAppProps>;
    PumperBundlesVolumeDiscount: _gem_sdk_core.ComponentSetting<PumperBundlesVolumeDiscountProps>;
    NotifyBackInStockPreOrder: _gem_sdk_core.ComponentSetting<NotifyBackInStockPreOrderProps>;
    ShopifyForms: _gem_sdk_core.ComponentSetting<ShopifyFormsProps>;
    SkioSubscriptionsYcS20: _gem_sdk_core.ComponentSetting<SkioSubscriptionsYcS20Props>;
    LoopSubscriptions: _gem_sdk_core.ComponentSetting<LoopSubscriptionsProps>;
    RecurpaySubscriptionApp: _gem_sdk_core.ComponentSetting<RecurpaySubscriptionAppProps>;
    SubifySubscriptionsApp: _gem_sdk_core.ComponentSetting<SubifySubscriptionsAppProps>;
    BonLoyaltyRewardsReferrals: _gem_sdk_core.ComponentSetting<BonLoyaltyRewardsReferralsProps>;
    ShopifySubscriptions: _gem_sdk_core.ComponentSetting<ShopifySubscriptionsProps>;
    EasifyProductOptions: _gem_sdk_core.ComponentSetting<EasifyProductOptionsProps>;
    CustomProductOptionsVariant: _gem_sdk_core.ComponentSetting<CustomProductOptionsVariantProps>;
    EasySellCOD: _gem_sdk_core.ComponentSetting<EasySellCODProps>;
    QikifyUpsell: _gem_sdk_core.ComponentSetting<QikifyUpsellProps>;
    CleanSizeCharts: _gem_sdk_core.ComponentSetting<CleanSizeChartsProps>;
    JudgemeReviews: _gem_sdk_core.ComponentSetting<JudgemeReviewsProps>;
    LooxReviews: _gem_sdk_core.ComponentSetting<LooxReviewsProps>;
    Klaviyo: _gem_sdk_core.ComponentSetting<KlaviyoProps>;
    YotpoLoyalty: _gem_sdk_core.ComponentSetting<YotpoLoyaltyProps>;
    SmartSearchBarAndFilters: _gem_sdk_core.ComponentSetting<SmartSearchBarAndFiltersProps>;
    Instafeed: _gem_sdk_core.ComponentSetting<InstafeedProps>;
    ProductReviews: _gem_sdk_core.ComponentSetting<ProductReviewsProps>;
    Ryviu: _gem_sdk_core.ComponentSetting<RyviuProps>;
    Rivyo: _gem_sdk_core.ComponentSetting<RivyoProps>;
    Vitals: _gem_sdk_core.ComponentSetting<VitalsProps>;
    Omnisend: _gem_sdk_core.ComponentSetting<OmnisendProps>;
    Trustoo: _gem_sdk_core.ComponentSetting<TrustooProps>;
    SealSubscriptions: _gem_sdk_core.ComponentSetting<SealSubscriptionsProps>;
    AppstleSubscriptions: _gem_sdk_core.ComponentSetting<AppstleSubscriptionsProps>;
    FeraReviews: _gem_sdk_core.ComponentSetting<FeraReviewsProps>;
    Growave: _gem_sdk_core.ComponentSetting<GrowaveProps>;
    KachingBundles: _gem_sdk_core.ComponentSetting<KachingBundlesProps>;
    PushOwl: _gem_sdk_core.ComponentSetting<PushOwlProps>;
    Opinew: _gem_sdk_core.ComponentSetting<OpinewProps>;
    UltimateSalesBoost: _gem_sdk_core.ComponentSetting<UltimateSalesBoostProps>;
    FirePush: _gem_sdk_core.ComponentSetting<FirePushProps>;
    ParcelPanel: _gem_sdk_core.ComponentSetting<ParcelPanelProps>;
    TrustMe: _gem_sdk_core.ComponentSetting<TrustMeProps>;
    FrequentlyBoughtTogether: _gem_sdk_core.ComponentSetting<FrequentlyBoughtTogetherProps>;
    BoldSubscriptions: _gem_sdk_core.ComponentSetting<BoldSubscriptionsProps>;
    BoldProductOptions: _gem_sdk_core.ComponentSetting<BoldProductOptionsProps>;
    WideBundle: _gem_sdk_core.ComponentSetting<WideBundleProps>;
    PickyStory: _gem_sdk_core.ComponentSetting<PickyStoryProps>;
    InfiniteOptions: _gem_sdk_core.ComponentSetting<InfiniteOptionsProps>;
    Wiser: _gem_sdk_core.ComponentSetting<WiserProps>;
    Stamped: _gem_sdk_core.ComponentSetting<StampedProps>;
    Bundler: _gem_sdk_core.ComponentSetting<BundlerProps>;
    LaiProductReviews: _gem_sdk_core.ComponentSetting<LaiProductReviewsProps>;
    CrossSellCartUpsell: _gem_sdk_core.ComponentSetting<CrossSellCartUpsellProps>;
    BoostAISearchDiscovery: _gem_sdk_core.ComponentSetting<BoostAISearchDiscoveryProps>;
    YotpoReviews: _gem_sdk_core.ComponentSetting<YotpoReviewsProps>;
    AliReviews: _gem_sdk_core.ComponentSetting<AliReviewsProps>;
    Bogos: _gem_sdk_core.ComponentSetting<BogosProps>;
    Releasit: _gem_sdk_core.ComponentSetting<ReleasitProps>;
    KingProductOptions: _gem_sdk_core.ComponentSetting<KingProductOptionsProps>;
    KlarnaMessaging: _gem_sdk_core.ComponentSetting<KlarnaMessagingProps>;
    RequestQuoteHidePrice: _gem_sdk_core.ComponentSetting<RequestQuoteHidePriceProps>;
    BirdChime: _gem_sdk_core.ComponentSetting<BirdChimeProps>;
    FordeerProductLabels: _gem_sdk_core.ComponentSetting<FordeerProductLabelsProps>;
    RechargeSubscriptions: _gem_sdk_core.ComponentSetting<RechargeSubscriptionsProps>;
    Selleasy: _gem_sdk_core.ComponentSetting<SelleasyProps>;
    HextomCountdownTimerBar: _gem_sdk_core.ComponentSetting<HextomCountdownTimerBarProps>;
    TrustBadgesBear: _gem_sdk_core.ComponentSetting<TrustBadgesBearProps>;
    TrustedsiteTrustBadges: _gem_sdk_core.ComponentSetting<TrustedsiteTrustBadgesProps>;
    GloColorSwatchvariantImage: _gem_sdk_core.ComponentSetting<GloColorSwatchvariantImageProps>;
    BfSizeChartSizeGuide: _gem_sdk_core.ComponentSetting<BfSizeChartSizeGuideProps>;
    AlsoBoughtCbb: _gem_sdk_core.ComponentSetting<AlsoBoughtCbbProps>;
    HextomFreeShippingBar: _gem_sdk_core.ComponentSetting<HextomFreeShippingBarProps>;
    EcoboostifyShoppableReelUgc: _gem_sdk_core.ComponentSetting<EcoboostifyShoppableReelUgcProps>;
    EcomsendBackInStockAlert: _gem_sdk_core.ComponentSetting<EcomsendBackInStockAlertProps>;
    AppstleBundlesDiscounts: _gem_sdk_core.ComponentSetting<AppstleBundlesDiscountsProps>;
    AovFreeGiftBuyXGetYBogo: _gem_sdk_core.ComponentSetting<AovFreeGiftBuyXGetYBogoProps>;
    AovBundlesVolumeDiscounts: _gem_sdk_core.ComponentSetting<AovBundlesVolumeDiscountsProps>;
    UppromoteAffiliateMarketing: _gem_sdk_core.ComponentSetting<UppromoteAffiliateMarketingProps>;
    DealeasyVolumeDiscounts: _gem_sdk_core.ComponentSetting<DealeasyVolumeDiscountsProps>;
    BloyRewardsProgramLoyalty: _gem_sdk_core.ComponentSetting<BloyRewardsProgramLoyaltyProps>;
    KachingSubscriptionsApp: _gem_sdk_core.ComponentSetting<KachingSubscriptionsAppProps>;
    GrowthSuiteDiscountCodes: _gem_sdk_core.ComponentSetting<GrowthSuiteDiscountCodesProps>;
    BonySubscriptionsApp: _gem_sdk_core.ComponentSetting<BonySubscriptionsAppProps>;
    WcWishlistBackInStock: _gem_sdk_core.ComponentSetting<WcWishlistBackInStockProps>;
    EssentPreorderBackInStock: _gem_sdk_core.ComponentSetting<EssentPreorderBackInStockProps>;
    Video: _gem_sdk_core.ComponentSetting<VideoProps>;
    Textarea: _gem_sdk_core.ComponentSetting<TextareaProps>;
    Text: _gem_sdk_core.ComponentSetting<TextProps>;
    Tabs: _gem_sdk_core.ComponentSetting<TabsProps>;
    TabItem: _gem_sdk_core.ComponentSetting<TabItemProps>;
    Select: _gem_sdk_core.ComponentSetting<SelectProps>;
    Radio: _gem_sdk_core.ComponentSetting<RadioProps>;
    Product: _gem_sdk_core.ComponentSetting<ProductProps>;
    ProductQuantity: _gem_sdk_core.ComponentSetting<ProductQuantityProps>;
    ProductTitle: _gem_sdk_core.ComponentSetting<ProductTitleProps>;
    ProductButton: _gem_sdk_core.ComponentSetting<ProductButtonProps>;
    ProductPrice: _gem_sdk_core.ComponentSetting<ProductPriceProps>;
    ProductVariants: _gem_sdk_core.ComponentSetting<ProductVariantsProps>;
    ProductImages: _gem_sdk_core.ComponentSetting<ProductImagesProps>;
    ProductImagesV2: _gem_sdk_core.ComponentSetting<ProductImagesProps$1>;
    ProductImagesV3: _gem_sdk_core.ComponentSetting<ProductImagesProps$2>;
    ProductDescription: _gem_sdk_core.ComponentSetting<ProductDescriptionProps>;
    ProductProperties: _gem_sdk_core.ComponentSetting<ProductPropertiesProps>;
    ProductTag: _gem_sdk_core.ComponentSetting<ProductTagProps>;
    ProductListV3: _gem_sdk_core.ComponentSetting<ProductListProps$1>;
    ProductList: _gem_sdk_core.ComponentSetting<ProductListProps>;
    DynamicCheckout: _gem_sdk_core.ComponentSetting<ProductButtonProps>;
    ProductVendor: _gem_sdk_core.ComponentSetting<VendorProps>;
    ProductSku: _gem_sdk_core.ComponentSetting<SkuProps>;
    ProductBundleDiscount: _gem_sdk_core.ComponentSetting<ProductBundleDiscountProps>;
    ProductBundleDiscountItem: _gem_sdk_core.ComponentSetting<ProductBundleDiscountProps>;
    ProductViewMore: _gem_sdk_core.ComponentSetting<ProductViewMoreProps>;
    ProductBadge: _gem_sdk_core.ComponentSetting<ProductBadgeProps>;
    FileUpload: _gem_sdk_core.ComponentSetting<FileUploadProps>;
    Pagination: _gem_sdk_core.ComponentSetting<PaginationProps>;
    Modal: _gem_sdk_core.ComponentSetting<ModalProps>;
    Menu: _gem_sdk_core.ComponentSetting<MenuProps>;
    Marquee: _gem_sdk_core.ComponentSetting<MarqueeProps>;
    MarqueeItem: _gem_sdk_core.ComponentSetting<MarqueeItemProps>;
    Link: _gem_sdk_core.ComponentSetting<LinkProps>;
    Line: _gem_sdk_core.ComponentSetting<LineProps>;
    Input: _gem_sdk_core.ComponentSetting<InputProps>;
    ImageDetection: _gem_sdk_core.ComponentSetting<ImageDetectionProps>;
    ImageComparison: _gem_sdk_core.ComponentSetting<ImageComparisonProps>;
    Image: _gem_sdk_core.ComponentSetting<ImageProps>;
    IconListV2: _gem_sdk_core.ComponentSetting<IconListProps>;
    IconListHoz: _gem_sdk_core.ComponentSetting<IconListHozProps>;
    IconListItemHoz: _gem_sdk_core.ComponentSetting<IconListItemProps>;
    IconList: _gem_sdk_core.ComponentSetting<IconListProps$1>;
    IconListItem: _gem_sdk_core.ComponentSetting<IconListItemProps$1>;
    Icon: _gem_sdk_core.ComponentSetting<IconProps>;
    Heading: _gem_sdk_core.ComponentSetting<HeadingProps>;
    Header: _gem_sdk_core.ComponentSetting<HeaderProps>;
    Newsletter: _gem_sdk_core.ComponentSetting<NewsletterProps>;
    FormEmail: _gem_sdk_core.ComponentSetting<FormEmailProps>;
    SubmitButton: _gem_sdk_core.ComponentSetting<SubmitButtonProps>;
    FormDropdown: _gem_sdk_core.ComponentSetting<FormDropdownProps>;
    TextField: _gem_sdk_core.ComponentSetting<TextFieldProps>;
    FormCheckbox: _gem_sdk_core.ComponentSetting<FormCheckboxProps>;
    TextInput: _gem_sdk_core.ComponentSetting<TextInputProps>;
    FormTextarea: _gem_sdk_core.ComponentSetting<TextAreaProps>;
    ContactForm: _gem_sdk_core.ComponentSetting<NewsletterProps>;
    Root: _gem_sdk_core.ComponentSetting<any>;
    Section: _gem_sdk_core.ComponentSetting<RowProps>;
    Row: _gem_sdk_core.ComponentSetting<RowProps>;
    Col: _gem_sdk_core.ComponentSetting<ColProps>;
    EstimateDate: _gem_sdk_core.ComponentSetting<EstimateDateProps>;
    Dialog: _gem_sdk_core.ComponentSetting<DialogProps$1>;
    Coupon: _gem_sdk_core.ComponentSetting<CouponProps>;
    Countdown: _gem_sdk_core.ComponentSetting<CountdownProps>;
    CollectionTitle: _gem_sdk_core.ComponentSetting<CollectionTitleProps>;
    CollectionBanner: _gem_sdk_core.ComponentSetting<CollectionBannerProps>;
    CollectionDescription: _gem_sdk_core.ComponentSetting<CollectionDescriptionProps>;
    CollectionToolbar: _gem_sdk_core.ComponentSetting<CollectionToolbarProps>;
    CollectionPaginator: _gem_sdk_core.ComponentSetting<CollectionPaginatorProps>;
    CSSCode: _gem_sdk_core.ComponentSetting<CSSCodeProps>;
    Cart: _gem_sdk_core.ComponentSetting<CartSidebarSettingProps>;
    CartList: _gem_sdk_core.ComponentSetting<CartListSidebarSettingProps>;
    CartLinePrice: _gem_sdk_core.ComponentSetting<CartLinePriceSidebarSettingProps>;
    CartLineVariant: _gem_sdk_core.ComponentSetting<CartLineVariantSidebarSettingProps>;
    CartLineImage: _gem_sdk_core.ComponentSetting<CartLineImageSidebarSettingProps>;
    CartTotalPrice: _gem_sdk_core.ComponentSetting<CartTotalPriceSidebarSettingProps>;
    CartTotalItem: _gem_sdk_core.ComponentSetting<CartTotalItemSidebarSettingProps>;
    CartCheckout: _gem_sdk_core.ComponentSetting<CartCheckoutProps>;
    DiscountInput: _gem_sdk_core.ComponentSetting<DiscountInputSidebarSettingProps>;
    CartDiscount: _gem_sdk_core.ComponentSetting<CartDiscountProps>;
    CartOrderNote: _gem_sdk_core.ComponentSetting<CartOrderNoteSidebarSettingProps>;
    CartLineAttribute: _gem_sdk_core.ComponentSetting<CartLineAttributeSidebarSettingProps>;
    CouponList: _gem_sdk_core.ComponentSetting<CouponListProps>;
    ShopPayButton: _gem_sdk_core.ComponentSetting<ShopPayButtonSidebarSettingProps>;
    Carousel: _gem_sdk_core.ComponentSetting<CarouselProps>;
    CarouselItem: _gem_sdk_core.ComponentSetting<CarouselItemProps>;
    CarouselV3: _gem_sdk_core.ComponentSetting<CarouselProps$1>;
    CarouselItemV3: _gem_sdk_core.ComponentSetting<CarouselItemProps$1>;
    Button: _gem_sdk_core.ComponentSetting<ButtonProps>;
    Breadcrumb: _gem_sdk_core.ComponentSetting<BreadcrumbProps>;
    HeroBanner: _gem_sdk_core.ComponentSetting<HeroBannerProps>;
    ArticleList: _gem_sdk_core.ComponentSetting<ArticleListProps>;
    ArticleTitle: _gem_sdk_core.ComponentSetting<ArticleTitleProps>;
    ArticleExcerpt: _gem_sdk_core.ComponentSetting<ArticleExcerptProps>;
    ArticleContent: _gem_sdk_core.ComponentSetting<ArticleContentProps>;
    ArticleImage: _gem_sdk_core.ComponentSetting<ArticleImageProps>;
    ArticlePagination: _gem_sdk_core.ComponentSetting<CollectionPaginatorProps>;
    ArticleAuthor: _gem_sdk_core.ComponentSetting<ArticleAuthorProps>;
    ArticleTag: _gem_sdk_core.ComponentSetting<ArticleTagProps>;
    ArticleCategory: _gem_sdk_core.ComponentSetting<ArticleCategoryProps>;
    ArticleDate: _gem_sdk_core.ComponentSetting<ArticleDateProps>;
    ArticleReadMore: _gem_sdk_core.ComponentSetting<ArticleReadMoreSidebarSettingProps>;
    Accordion: _gem_sdk_core.ComponentSetting<AccordionProps>;
    AccordionItem: _gem_sdk_core.ComponentSetting<AccordionItemProps>;
};

declare const _default: {
    PostPurchaseBuyerConsent: _gem_sdk_core.ComponentSetting<PostPurchaseBuyerConsentProps>;
    PostPurchaseText: _gem_sdk_core.ComponentSetting<PostPurchaseTextProps>;
    PostPurchaseHeading: _gem_sdk_core.ComponentSetting<PostPurchaseTextProps>;
    PostPurchaseProductTitle: _gem_sdk_core.ComponentSetting<PostPurchaseProductTitleProps>;
    PostPurchaseProductDescription: _gem_sdk_core.ComponentSetting<PostPurchaseProductDescriptionProps>;
    PostPurchaseProductPrice: _gem_sdk_core.ComponentSetting<PostPurchaseProductPriceProps>;
    PostPurchaseProductVariants: _gem_sdk_core.ComponentSetting<PostPurchaseProductVariantsProps>;
    PostPurchaseAcceptButton: _gem_sdk_core.ComponentSetting<PostPurchaseButtonProps>;
    PostPurchaseProductQuantity: _gem_sdk_core.ComponentSetting<PostPurchaseProductQuantityProps>;
    PostPurchaseProductPriceBreakdown: _gem_sdk_core.ComponentSetting<PostPurchaseProductPriceBreakdownProps>;
    PostPurchaseProductOffer: _gem_sdk_core.ComponentSetting<PostPurchaseProductOfferProps>;
    PostPurchaseProductDiscountTag: _gem_sdk_core.ComponentSetting<PostPurchaseProductDiscountTagProps>;
    PostPurchaseProductImages: _gem_sdk_core.ComponentSetting<PostPurchaseProductImagesProps>;
    PostPurchaseProductSubscription: _gem_sdk_core.ComponentSetting<PostPurchaseProductSubscriptionProps>;
    PostPurchaseLink: _gem_sdk_core.ComponentSetting<PostPurchaseLinkProps>;
    PostPurchaseLine: _gem_sdk_core.ComponentSetting<PostPurchaseLineProps>;
    PostPurchaseImage: _gem_sdk_core.ComponentSetting<PostPurchaseImageProps>;
    PostPurchaseCountdownTimer: _gem_sdk_core.ComponentSetting<PostPurchaseCountdownTimerProps>;
    PostPurchaseCalloutBox: _gem_sdk_core.ComponentSetting<CalloutBoxProps>;
    PostPurchaseCalloutText: _gem_sdk_core.ComponentSetting<CalloutTextProps>;
    PostPurchaseButton: _gem_sdk_core.ComponentSetting<PostPurchaseButtonProps>;
    PostPurchaseAdvancedList: _gem_sdk_core.ComponentSetting<PostPurchaseAdvancedListProps>;
    PostPurchaseAdvancedListItem: _gem_sdk_core.ComponentSetting<PostPurchaseAdvancedListItemProps>;
    Root: _gem_sdk_core.ComponentSetting<any>;
    Section: _gem_sdk_core.ComponentSetting<RowProps>;
    Row: _gem_sdk_core.ComponentSetting<RowProps>;
    Col: _gem_sdk_core.ComponentSetting<ColProps>;
};

type TranslateElement = {
    id: string;
    fields?: string[];
};
type TranslateObject<T extends string = string> = Partial<Record<T, TranslateElement>>;

declare const ELEMENT_Z_INDEX: {
    STICKY: number;
    DIALOG: number;
    CART_DRAWER: number;
    CART_DRAWER_CONFIRM_MODAL: number;
};

declare const QUANTITY_SOURCE: {
    readonly AUTO: "auto";
    readonly MANUAL: "manual";
};
declare const OUT_OF_STOCK: {
    readonly SHOW: "show";
    readonly HIDE: "hide";
};
declare const DEFAULT_QUANTITY_TEMPLATE = "%number%";
declare const DEFAULT_HIGHLIGHT_TAG = "mark";
declare const NO_PRODUCT_LEFT = 0;
declare const DEFAULT_SCARCITY_THRESHOLD = 12;
declare const DEFAULT_REMAINING_QUANTITY = 12;
declare const DEFAULT_REMAINING_PERCENT = 20;
declare const MIN_REMAINING_QUANTITY = 0;
declare const MIN_REMAINING_PERCENT = 10;
declare const MAX_REMAINING_PERCENT = 100;
declare const DEFAULT_RANGE_STEP = 10;
declare const DEFAULT_FONT_SIZE = 20;
declare const DEFAULT_PROGRESS_BAR_HEIGHT = 10;
declare const MIN_PROGRESS_BAR_HEIGHT = 5;
declare const MAX_PROGRESS_BAR_HEIGHT = 20;
declare const CONTINUE_SELLING_WHEN_OUT_OF_STOCK = "CONTINUE";
declare const getLiquidTextContent: (data: Record<string, any>) => string;
declare const getLiquidInitData: (setting: StockCounterProps["setting"], styles: StockCounterProps["styles"]) => string;
declare const getTextDisplayData: (data: Record<string, any>, styles: StockCounterProps["styles"]) => string;
declare const getInlineCss: (uniqId?: string, borderRadius?: CornerRadius) => string | undefined;
declare const transformHighlighTag: (template: string, stringColor: string) => string;
declare const transformNumberTag: (template: string, stringColor: string, quantityLeft: string | number) => string;
declare const convertSizeToWidth: (typographyVar: React.CSSProperties) => Record<string, string>;

type DynamicSource = {
    val: React.ReactNode;
    uid?: string;
    settingId?: string;
    isLiquid?: boolean;
    pageContext: PageContext;
    isCapitalize?: boolean;
    defaultVal?: string;
    isReplaceLocationOrigin?: boolean;
    isReplaceMaxSize?: boolean;
    isReplaceInventoryQuantity?: boolean;
};
declare const REGEX_PAGE_TYPE: RegExp;
declare const isShopifyDomain: (isHyperlink: boolean, urlHref: string) => boolean;
declare const getLinkArticle: (linkArticle?: string, customURL?: {
    link?: string;
    target?: string;
    type?: any;
}) => string | undefined;
declare const isTransparentColor: (str?: string) => boolean;
declare const isTransparentRGBA: (rgbStr: string) => boolean;
declare const isHexTransparent: (hex: string) => boolean;
declare const youtubeShortsRegex: RegExp;
declare const createTranslateKey: (uid?: string, settingId?: string) => string;
declare const createSettingId: ({ id, index, suffix, }: {
    id?: string;
    index?: number;
    suffix?: string;
}) => string;
declare const getDynamicSourceLocales: ({ val, uid, settingId, isLiquid, pageContext, isCapitalize, defaultVal, isReplaceLocationOrigin, isReplaceMaxSize, isReplaceInventoryQuantity, }: DynamicSource) => string | number | boolean | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>;
declare const getStaticLocale: (tag: string, key: string) => string;
declare const getSettingPreloadData: (disabledValue: string, enabledValue?: string) => string;
declare function normalizeMailto(urlHref: string): string;
declare const getInsertLinkData: (defaultWrap: string, setting?: {
    link?: string;
    target?: string;
    isTranslate?: boolean;
    type?: string;
    noFollow?: boolean;
    isLiquid?: boolean;
}, htmlType?: React.ButtonHTMLAttributes<HTMLButtonElement>["type"] | "link") => {
    Wrap: string | React.FC<LinkProps>;
    urlData: Record<string, any>;
    shouldRenderLink: boolean;
};
declare const isLinkedToSalesPage: (type?: string) => type is "go-to-sales-page";
declare const checkIsScrollToTop: (setting?: ImageLink) => boolean;
declare const checkIsOpenPopup: (setting?: ImageLink) => boolean | undefined;
declare const getLinkData: ({ setting, htmlType, defaultWrap, isLiquid, enableImageLink, }: {
    isLiquid?: boolean;
    defaultWrap: string;
    enableImageLink?: boolean;
    setting?: ImageLink;
    htmlType?: React.ButtonHTMLAttributes<HTMLButtonElement>["type"] | "link";
}) => {
    Wrapper: string | React.FC<LinkProps>;
    urlData: Record<string, any>;
    shouldRenderLink: boolean;
};
declare const replaceLinkData: (text?: string, isTranslate?: boolean) => string | undefined;
declare function filterTruthyStyles<T extends Record<string, any>>(styles: T): Partial<T>;
declare function filterTruthyObject<T extends Record<string, any>>(obj: T): Partial<T>;
declare const getDisplayStyle: (fnCondition: (params: NameDevices) => boolean, defaultValue: string) => any;
declare const convertUnitToNumber: (value: string | undefined | number, defaultValue: number) => number;
declare const getAllHrefFromString: (htmlString: string) => string[];
declare const replaceAllHrefFromString: (htmlString: string, hrefs: string[]) => string;
declare function isEmptyObject(obj: Record<string, any>): boolean;
declare const handleClickLink: (setting?: ImageLink, mode?: RenderMode) => void;
declare const getSeoTranslated: ({ valueTranslate, uid, settingId, pageContext, }: {
    valueTranslate?: string;
    settingId: "alt" | "title";
    uid?: string;
    pageContext: PageContext;
}) => string | undefined;
declare const getBackgroundTranslated: ({ background, enableTranslate, uid, pageContext, isTranslateVideo, }: {
    background?: ObjectDevices<BackgroundMedia>;
    enableTranslate?: boolean;
    uid?: string;
    pageContext: PageContext;
    isTranslateVideo?: boolean;
}) => ObjectDevices<BackgroundMedia>;
declare const extractProductID: (baseID: string) => string;
declare const filterPageContext: (pageContext?: PageContext) => {
    numberOfProductOfProductList?: number;
    isPreviewing?: boolean;
    pageType?: string;
    isTranslateWithLocale?: boolean;
    sectionName?: string;
    isOptimizePlan?: boolean;
    showPriceCurrency?: boolean;
    enableLazyLoadImage?: boolean;
    hasCollectionHandle?: boolean;
} | undefined;

declare const Accordion: TranslateObject<AccordionTranslateKeys>;

declare const IconListV2: TranslateObject<IconListV2TranslateKeys>;

declare const Text: TranslateObject<TextTranslateKeys>;

declare const Heading: TranslateObject<HeadingTranslateKeys>;

declare const CSSCode: TranslateObject<CSSCodeTranslateKeys>;

declare const Dialog: TranslateObject<DialogTranslateKeys>;

declare const Tabs: TranslateObject<TabsTranslateKeys>;

declare const Button: TranslateObject<ButtonTranslateKeys>;

declare const Image: TranslateObject<ImageTranslateKeys>;

declare const Sticky: TranslateObject<StickyTranslateKeys>;

declare const IconList: TranslateObject<IconListTranslateKeys>;

declare const ImageComparison: TranslateObject<ImageComparisonTranslateKeys>;

declare const Countdown: TranslateObject<CountdownTimerTranslateKeys>;

declare const Coupon: TranslateObject<CouponTranslateKeys>;

declare const StockCounter: TranslateObject<StockCounterTranslateKeys>;

declare const ProductViewMore: TranslateObject<'label'>;

declare const ProductProperties: TranslateObject<'label' | 'placeholder' | 'childItem' | 'requiredMessage' | 'invalidEmailMessage' | 'invalidNumberMessage' | 'invalidLengthMessage'>;

declare const ProductDiscountTag: TranslateObject<keyof ProductTagSidebarSettingProps['setting']>;
declare const ProductTag: TranslateObject<keyof ProductTagSidebarSettingProps['setting']>;

declare const ProductDescription: TranslateObject<'viewMoreText' | 'viewLessText'>;

declare const ProductButton: TranslateObject<ProductButtonPropsTranslateKeys>;

declare const ProductBadge: TranslateObject<'displayContent'>;

declare const FileUpload: TranslateObject<'textContent'>;

declare const ArticleReadMore: TranslateObject<ArticleReadMoreTranslateKeys>;
declare const ArticlePagination: TranslateObject<ArticlePaginationTranslateKeys>;

declare const CollectionToolbar: TranslateObject<CollectionToolbarTranslateKeys>;

declare const CollectionPaginator: TranslateObject<CollectionPaginatorTranslateKeys>;

declare const CollectionDescription: TranslateObject<CollectionDescriptionTranslateKeys>;

declare const EstimateDate: TranslateObject<EstimateDateTranslateKeys>;

declare const HeroBanner: TranslateObject<HeroBannerTranslateKeys>;

declare const Row: TranslateObject<RowTranslateKeys>;
declare const Section: TranslateObject<RowTranslateKeys>;

declare const Video: TranslateObject<VideoTranslateKeys>;

declare const TextInput: TranslateObject<'placeholder'>;

declare const TextField: TranslateObject<'placeholder'>;

declare const SubmitButton: TranslateObject<'label'>;

declare const Newsletter: TranslateObject<'successMessage' | 'errorMessage'>;

declare const FormTextarea: TranslateObject<'placeholder'>;

declare const FormEmail: TranslateObject<'placeholder'>;

declare const FormDropdown: TranslateObject<'childItem'>;

declare const FormCheckbox: TranslateObject<'description'>;

declare const ContactForm: TranslateObject<'successMessage' | 'errorMessage'>;

declare const translate_Accordion: typeof Accordion;
declare const translate_ArticlePagination: typeof ArticlePagination;
declare const translate_ArticleReadMore: typeof ArticleReadMore;
declare const translate_Button: typeof Button;
declare const translate_CSSCode: typeof CSSCode;
declare const translate_CollectionDescription: typeof CollectionDescription;
declare const translate_CollectionPaginator: typeof CollectionPaginator;
declare const translate_CollectionToolbar: typeof CollectionToolbar;
declare const translate_ContactForm: typeof ContactForm;
declare const translate_Countdown: typeof Countdown;
declare const translate_Coupon: typeof Coupon;
declare const translate_Dialog: typeof Dialog;
declare const translate_EstimateDate: typeof EstimateDate;
declare const translate_FileUpload: typeof FileUpload;
declare const translate_FormCheckbox: typeof FormCheckbox;
declare const translate_FormDropdown: typeof FormDropdown;
declare const translate_FormEmail: typeof FormEmail;
declare const translate_FormTextarea: typeof FormTextarea;
declare const translate_Heading: typeof Heading;
declare const translate_HeroBanner: typeof HeroBanner;
declare const translate_IconList: typeof IconList;
declare const translate_IconListV2: typeof IconListV2;
declare const translate_Image: typeof Image;
declare const translate_ImageComparison: typeof ImageComparison;
declare const translate_Newsletter: typeof Newsletter;
declare const translate_ProductBadge: typeof ProductBadge;
declare const translate_ProductButton: typeof ProductButton;
declare const translate_ProductDescription: typeof ProductDescription;
declare const translate_ProductDiscountTag: typeof ProductDiscountTag;
declare const translate_ProductProperties: typeof ProductProperties;
declare const translate_ProductTag: typeof ProductTag;
declare const translate_ProductViewMore: typeof ProductViewMore;
declare const translate_Row: typeof Row;
declare const translate_Section: typeof Section;
declare const translate_Sticky: typeof Sticky;
declare const translate_StockCounter: typeof StockCounter;
declare const translate_SubmitButton: typeof SubmitButton;
declare const translate_Tabs: typeof Tabs;
declare const translate_Text: typeof Text;
declare const translate_TextField: typeof TextField;
declare const translate_TextInput: typeof TextInput;
declare const translate_Video: typeof Video;
declare namespace translate {
  export {
    translate_Accordion as Accordion,
    translate_ArticlePagination as ArticlePagination,
    translate_ArticleReadMore as ArticleReadMore,
    translate_Button as Button,
    translate_CSSCode as CSSCode,
    translate_CollectionDescription as CollectionDescription,
    translate_CollectionPaginator as CollectionPaginator,
    translate_CollectionToolbar as CollectionToolbar,
    translate_ContactForm as ContactForm,
    translate_Countdown as Countdown,
    translate_Coupon as Coupon,
    translate_Dialog as Dialog,
    translate_EstimateDate as EstimateDate,
    translate_FileUpload as FileUpload,
    translate_FormCheckbox as FormCheckbox,
    translate_FormDropdown as FormDropdown,
    translate_FormEmail as FormEmail,
    translate_FormTextarea as FormTextarea,
    translate_Heading as Heading,
    translate_HeroBanner as HeroBanner,
    translate_IconList as IconList,
    translate_IconListV2 as IconListV2,
    translate_Image as Image,
    translate_ImageComparison as ImageComparison,
    translate_Newsletter as Newsletter,
    translate_ProductBadge as ProductBadge,
    translate_ProductButton as ProductButton,
    translate_ProductDescription as ProductDescription,
    translate_ProductDiscountTag as ProductDiscountTag,
    translate_ProductProperties as ProductProperties,
    translate_ProductTag as ProductTag,
    translate_ProductViewMore as ProductViewMore,
    translate_Row as Row,
    translate_Section as Section,
    translate_Sticky as Sticky,
    translate_StockCounter as StockCounter,
    translate_SubmitButton as SubmitButton,
    translate_Tabs as Tabs,
    translate_Text as Text,
    translate_TextField as TextField,
    translate_TextInput as TextInput,
    translate_Video as Video,
  };
}

declare const TAGS_WITH_REPLACE_LINK_DATA: string[];

export { Accordion$2 as Accordion, AccordionItem$1 as AccordionItem, AftershipEmailMarketingsms$1 as AftershipEmailMarketingsms, AirProductReviewsAppUgc$1 as AirProductReviewsAppUgc, AliReviews$1 as AliReviews, AlsoBoughtCbb$1 as AlsoBoughtCbb, AovBundlesVolumeDiscounts$1 as AovBundlesVolumeDiscounts, AovFreeGiftBuyXGetYBogo$1 as AovFreeGiftBuyXGetYBogo, AppointmentBookingCowlendar$1 as AppointmentBookingCowlendar, AppstleBundlesDiscounts$1 as AppstleBundlesDiscounts, AppstleSubscriptions$1 as AppstleSubscriptions, ArticleAuthor$1 as ArticleAuthor, ArticleCategory$1 as ArticleCategory, ArticleContent$1 as ArticleContent, ArticleDate$1 as ArticleDate, ArticleExcerpt$1 as ArticleExcerpt, ArticleImage$1 as ArticleImage, ArticleList$1 as ArticleList, ArticlePagination$2 as ArticlePagination, ArticleReadMore$2 as ArticleReadMore, ArticleTag$1 as ArticleTag, ArticleTitle$1 as ArticleTitle, BasicHeader, BestBuyFulfillment$1 as BestBuyFulfillment, BfSizeChartSizeGuide$1 as BfSizeChartSizeGuide, BirdChime$1 as BirdChime, BloyRewardsProgramLoyalty$1 as BloyRewardsProgramLoyalty, Bogos$1 as Bogos, BoldProductOptions$1 as BoldProductOptions, BoldSubscriptions$1 as BoldSubscriptions, BonLoyaltyRewardsReferrals$1 as BonLoyaltyRewardsReferrals, BonySubscriptionsApp$1 as BonySubscriptionsApp, BoostAISearchDiscovery$1 as BoostAISearchDiscovery, Breadcrumb$1 as Breadcrumb, Breadcrumb$1 as BreadcrumbProps, Bundler$1 as Bundler, Button$3 as Button, CONTINUE_SELLING_WHEN_OUT_OF_STOCK, CSSCode$2 as CSSCode, Carousel$2 as Carousel, CarouselItem$2 as CarouselItem, CarouselItem$3 as CarouselItemV3, Carousel$3 as CarouselV3, Cart, CartCheckout, CartDiscount, CartLineAttribute, CartLineImage, CartLinePrice, CartLineVariant, CartList, CartOrderNote, CartTotalItem, CartTotalPrice, CheckoutNow, CleanSizeCharts$1 as CleanSizeCharts, Column$1 as Col, CollectionBanner$1 as CollectionBanner, CollectionDescription$2 as CollectionDescription, CollectionPaginator$2 as CollectionPaginator, CollectionTitle$1 as CollectionTitle, CollectionToolbar$2 as CollectionToolbar, ContactForm$2 as ContactForm, Countdown$2 as Countdown, Coupon$2 as Coupon, CouponList, CrossSellCartUpsell$1 as CrossSellCartUpsell, CustomProductOptionsVariant$1 as CustomProductOptionsVariant, DEFAULT_FONT_SIZE, DEFAULT_HIGHLIGHT_TAG, DEFAULT_PROGRESS_BAR_HEIGHT, DEFAULT_QUANTITY_TEMPLATE, DEFAULT_RANGE_STEP, DEFAULT_REMAINING_PERCENT, DEFAULT_REMAINING_QUANTITY, DEFAULT_SCARCITY_THRESHOLD, DealeasyVolumeDiscounts$1 as DealeasyVolumeDiscounts, DesktopMenu, Dialog$2 as Dialog, DiscountInput, DiscountyBulkDiscountSales$1 as DiscountyBulkDiscountSales, DynamicCheckout$1 as DynamicCheckout, ELEMENT_Z_INDEX, EasifyProductOptions$1 as EasifyProductOptions, EasyBundleBuilderSkailama$1 as EasyBundleBuilderSkailama, EasySell as EasySellCOD, EcoboostifyShoppableReelUgc$1 as EcoboostifyShoppableReelUgc, EcomsendBackInStockAlert$1 as EcomsendBackInStockAlert, EssentPreorderBackInStock$1 as EssentPreorderBackInStock, EssentialAnnouncementBar$1 as EssentialAnnouncementBar, EssentialCountdownTimerBar$1 as EssentialCountdownTimerBar, EstimateDate$2 as EstimateDate, EstimatedDeliveryDatePlus$1 as EstimatedDeliveryDatePlus, FastBundleBundlesDiscounts$1 as FastBundleBundlesDiscounts, FeraReviews$1 as FeraReviews, FileUpload$2 as FileUpload, FirePush$1 as FirePush, FlyBundlesUpsellsFbt$1 as FlyBundlesUpsellsFbt, FordeerProductLabels$1 as FordeerProductLabels, FormCheckbox$1 as FormCheckbox, FormDropdown$2 as FormDropdown, FormEmail$2 as FormEmail, FormTextArea as FormTextarea, FrequentlyBoughtTogether$1 as FrequentlyBoughtTogether, GloColorSwatchvariantImage$1 as GloColorSwatchvariantImage, GloboProductOptionsVariant$1 as GloboProductOptionsVariant, GoogleReviewsByReputon$1 as GoogleReviewsByReputon, Growave$1 as Growave, GrowthSuiteDiscountCodes$1 as GrowthSuiteDiscountCodes, Header, Heading$2 as Heading, HeroBanner$2 as HeroBanner, HextomCountdownTimerBar$1 as HextomCountdownTimerBar, HextomFreeShippingBar$1 as HextomFreeShippingBar, HulkFormBuilder$1 as HulkFormBuilder, HulkProductOptions$1 as HulkProductOptions, Icon$1 as Icon, IconList$2 as IconList, IconListHoz$1 as IconListHoz, IconListItem$1 as IconListItem, IconListHozItem as IconListItemHoz, IconListV2$2 as IconListV2, Image$2 as Image, ImageComparison$2 as ImageComparison, ImageDetection, InfiniteOptions$1 as InfiniteOptions, Input, Instafeed$1 as Instafeed, InstantJudgemeReviews, InstantKlaviyo, InstantLooxReviews, InstantYotpoLoyalty, InstasellShoppableInstagram$1 as InstasellShoppableInstagram, JudgemeReviews$1 as JudgemeReviews, JunipProductReviewsUgc$1 as JunipProductReviewsUgc, KachingBundles$1 as KachingBundles, KachingSubscriptionsApp$1 as KachingSubscriptionsApp, KingProductOptions$1 as KingProductOptions, KiteFreeGiftDiscount$1 as KiteFreeGiftDiscount, KlarnaMessaging$1 as KlarnaMessaging, Klaviyo$1 as Klaviyo, KoalaBundleQuantityDiscount$1 as KoalaBundleQuantityDiscount, LaiProductReviews$1 as LaiProductReviews, Line$2 as Line, Link$1 as Link, LoloyalLoyaltyReferrals$1 as LoloyalLoyaltyReferrals, LoopSubscriptions$1 as LoopSubscriptions, LooxReviews$1 as LooxReviews, MAX_PROGRESS_BAR_HEIGHT, MAX_REMAINING_PERCENT, MIN_PROGRESS_BAR_HEIGHT, MIN_REMAINING_PERCENT, MIN_REMAINING_QUANTITY, Marquee$1 as Marquee, _default$5 as MarqueeItem, MaxbundleProductBundles$1 as MaxbundleProductBundles, MbcBundleVolumeDiscount$1 as MbcBundleVolumeDiscount, Menu, MobileMenu, Modal, ModernHeader, MyappgurusProductReviews$1 as MyappgurusProductReviews, NO_PRODUCT_LEFT, Newsletter$2 as Newsletter, Notify as Notice, NotifyBackInStockPreOrder$1 as NotifyBackInStockPreOrder, OUT_OF_STOCK, OkendoReviewsLoyalty$1 as OkendoReviewsLoyalty, Omnisend$1 as Omnisend, Opinew$1 as Opinew, Pagination, ParcelPanel$1 as ParcelPanel, PickyStory$1 as PickyStory, PostPurchaseAcceptButton, PostPurchaseAdvancedList, PostPurchaseAdvancedListItem, Button$2 as PostPurchaseButton, BuyerConsent as PostPurchaseBuyerConsent, CalloutBox as PostPurchaseCalloutBox, CalloutText as PostPurchaseCalloutText, PostPurchaseCountdownTimer, PostPurchaseHeading, PostPurchaseImage, Line$1 as PostPurchaseLine, Link as PostPurchaseLink, PostPurchaseProductDescription, PostPurchaseProductDiscountTag, PostPurchaseProductImages, PostPurchaseProductOffer, PostPurchaseProductPrice, PostPurchaseProductPriceBreakdown, PostPurchaseProductQuantity, ProductSubscription as PostPurchaseProductSubscription, PostPurchaseProductTitle, PostPurchaseProductVariants, Text$3 as PostPurchaseText, PowerfulContactFormBuilder$1 as PowerfulContactFormBuilder, PreorderNowPreOrderPq$1 as PreorderNowPreOrderPq, PreorderNowWodPresale$1 as PreorderNowWodPresale, Product$1 as Product, ProductBadge$2 as ProductBadge, ProductBundleDiscount$1 as ProductBundleDiscount, ProductBundleDiscountItem$1 as ProductBundleDiscountItem, ProductButton$2 as ProductButton, ProductDescription$2 as ProductDescription, ProductImages$3 as ProductImages, ProductImagesV2, ProductImagesV3, ProductList$2 as ProductList, ProductList$3 as ProductListV3, ProductOptionsCustomizer$1 as ProductOptionsCustomizer, ProductOptionsVariantOption$1 as ProductOptionsVariantOption, ProductPrice$1 as ProductPrice, ProductProperties$2 as ProductPropertyInput, ProductQuantity$1 as ProductQuantity, QuickView as ProductQuickView, ProductReviews$1 as ProductReviews, ProductSku$1 as ProductSku, ProductTag$2 as ProductTag, ProductTitle$1 as ProductTitle, ProductVariants$1 as ProductVariants, ProductVendor$1 as ProductVendor, ProductViewMore$2 as ProductViewMore, PumperBundlesVolumeDiscount$1 as PumperBundlesVolumeDiscount, PushOwl$1 as PushOwl, QUANTITY_SOURCE, QikifyUpsell$1 as QikifyUpsell, REGEX_PAGE_TYPE, Radio, RapiBundleQuantityBreaks$1 as RapiBundleQuantityBreaks, RechargeSubscriptions$1 as RechargeSubscriptions, RecurpaySubscriptionApp$1 as RecurpaySubscriptionApp, Releasit$1 as Releasit, RequestQuoteHidePrice$1 as RequestQuoteHidePrice, ReviewxpoProductReviewsApp$1 as ReviewxpoProductReviewsApp, Rivyo$1 as Rivyo, Root$1 as Root, Row$2 as Row, Ryviu$1 as Ryviu, SealSubscriptions$1 as SealSubscriptions, Section$2 as Section, SegunoEmailMarketing$1 as SegunoEmailMarketing, Select, Selleasy$1 as Selleasy, SeoantTrustBadgesIcon$1 as SeoantTrustBadgesIcon, ShopPayButton$1 as ShopPayButton, ShopPayInstallments$1 as ShopPayInstallments, ShopifyForms$1 as ShopifyForms, ShopifySubscriptions$1 as ShopifySubscriptions, SimpleBundlesKits$1 as SimpleBundlesKits, SkioSubscriptionsYcS20$1 as SkioSubscriptionsYcS20, SmartSearchBarAndFilters$1 as SmartSearchBarAndFilters, SproutPlantTreesGrowSales$1 as SproutPlantTreesGrowSales, Stamped$1 as Stamped, StellarDeliveryDatePickup$1 as StellarDeliveryDatePickup, Sticky$2 as Sticky, StockCounter$2 as StockCounter, SubifySubscriptionsApp$1 as SubifySubscriptionsApp, SubmitButton$2 as SubmitButton, TAGS_WITH_REPLACE_LINK_DATA, TabItem$1 as TabItem, Tabs$2 as Tabs, TagembedSocialPostReview$1 as TagembedSocialPostReview, TagshopShoppableVideosUgc$1 as TagshopShoppableVideosUgc, TeeinblueProductPersonalizer$1 as TeeinblueProductPersonalizer, Text$2 as Text, TextField$2 as TextField, TextInput$2 as TextInput, TextArea as Textarea, ThirdPartySlot$1 as ThirdPartySlot, TrustBadgesBear$1 as TrustBadgesBear, TrustMe$1 as TrustMe, TrustedsiteTrustBadges$1 as TrustedsiteTrustBadges, Trustoo$1 as Trustoo, TrustreviewsProductReviews$1 as TrustreviewsProductReviews, TrustshopProductReviews$1 as TrustshopProductReviews, UltimateSalesBoost$1 as UltimateSalesBoost, UnlimitedBundlesDiscounts$1 as UnlimitedBundlesDiscounts, UppromoteAffiliateMarketing$1 as UppromoteAffiliateMarketing, Video$2 as Video, Vitals$1 as Vitals, WcWishlistBackInStock$1 as WcWishlistBackInStock, WhatmoreShoppableVideosreel$1 as WhatmoreShoppableVideosreel, WideBundle$1 as WideBundle, Wiser$1 as Wiser, WishlistKing$1 as WishlistKing, WishlistPlus$1 as WishlistPlus, YotpoLoyalty, YotpoReviews$1 as YotpoReviews, accordionSetting, articleListSetting, bannerSetting, breadcrumbSetting, _default$2 as builderComponent, buttonSetting, carouselSetting, carouselSettingV3, cartSetting, checkIsOpenPopup, checkIsScrollToTop, codeSetting, collectionSetting, _default$1 as componentSettings, contactFormSetting, convertSizeToWidth, convertUnitToNumber, countdownSetting, couponSetting, createSettingId, createTranslateKey, dialogSetting, estimateDeliverySetting, extractProductID, filterPageContext, filterTruthyObject, filterTruthyStyles, getAllHrefFromString, getBackgroundTranslated, getDisplayStyle, getDynamicSourceLocales, getInlineCss, getInsertLinkData, getLinkArticle, getLinkData, getLiquidInitData, getLiquidTextContent, getSeoTranslated, getSettingPreloadData, getStaticLocale, getTextDisplayData, gridSetting, handleClickLink, headerSetting, headingSetting, _default$3 as headlessComponents, iconListHozSetting, iconListSetting, iconListSettingV2, iconSetting, imageComparisonSetting, imageDetectionSetting, imageSetting, inputSetting, isEmptyObject, isHexTransparent, isLinkedToSalesPage, isShopifyDomain, isTransparentColor, isTransparentRGBA, lineSetting, linkSetting, index_liquid as liquidComponents, marqueeSetting, menuSetting, modalSetting, _default$4 as nextComponent, normalizeMailto, openConfirm, paginationSetting, postPurchaseAdvancedListSetting, postPurchaseButtonSetting, postPurchaseBuyerConsentSetting, postPurchaseCalloutBoxSetting, postPurchaseCountdownTimerSetting, postPurchaseImageSetting, postPurchaseLineSetting, postPurchaseLinkSetting, postPurchaseProduct1Col, postPurchaseProduct2Col, postPurchaseProductDefault, postPurchaseProductSetting, _default as postPurchaseSettings, postPurchaseTextSetting, productSetting, radioSetting, replaceAllHrefFromString, replaceLinkData, selectSetting, shopPayInstallmentSetting, stickySetting, stockCounterSetting, tabSetting, textSetting, textareaSetting, thirdPartyInstantSetting, thirdPartySetting, thirdPartySlotSetting, transformHighlighTag, transformNumberTag, translate as translateComponents, useNotification, videoSetting, youtubeShortsRegex };
export type { AccordionItemProps, AccordionProps, AftershipEmailMarketingsmsProps, AirProductReviewsAppUgcProps, AliReviewsProps, AlsoBoughtCbbProps, AovBundlesVolumeDiscountsProps, AovFreeGiftBuyXGetYBogoProps, AppointmentBookingCowlendarProps, AppstleBundlesDiscountsProps, AppstleSubscriptionsProps, BestBuyFulfillmentProps, BfSizeChartSizeGuideProps, BirdChimeProps, BloyRewardsProgramLoyaltyProps, BogosProps, BoldProductOptionsProps, BoldSubscriptionsProps, BonLoyaltyRewardsReferralsProps, BonySubscriptionsAppProps, BoostAISearchDiscoveryProps, BundlerProps, ButtonProps, CSSCodeProps, CalloutBoxProps, CalloutTextProps, CarouselItemProps, CarouselItemProps$1 as CarouselItemPropsV3, CarouselProps, CarouselProps$1 as CarouselPropsV3, CarouselSettingProps, CarouselSettingProps$1 as CarouselSettingPropsV3, CarouselStyleProps, CarouselStyleProps$1 as CarouselStylePropsV3, CartProps, CleanSizeChartsProps, ColProps, CollectionBannerProps, CollectionDescriptionProps, CollectionPaginatorProps, CollectionTitleProps, CollectionToolbarProps, CountdownProps, CouponProps, CrossSellCartUpsellProps, CustomProductOptionsVariantProps, DataVideoType, DealeasyVolumeDiscountsProps, DiscountyBulkDiscountSalesProps, DynamicCheckoutProps, EasifyProductOptionsProps, EasyBundleBuilderSkailamaProps, EasySellCODProps, EcoboostifyShoppableReelUgcProps, EcomsendBackInStockAlertProps, EssentPreorderBackInStockProps, EssentialAnnouncementBarProps, EssentialCountdownTimerBarProps, EstimateDateProps, EstimatedDeliveryDatePlusProps, FastBundleBundlesDiscountsProps, FeraReviewsProps, FileUploadProps, FirePushProps, FlyBundlesUpsellsFbtProps, FordeerProductLabelsProps, FormCheckboxProps, FormDropdownProps, FormEmailProps, FrequentlyBoughtTogetherProps, GloColorSwatchvariantImageProps, GloboProductOptionsVariantProps, GoogleReviewsByReputonProps, GrowaveProps, GrowthSuiteDiscountCodesProps, HeaderProps, HeadingProps, HeroBannerProps, HextomCountdownTimerBarProps, HextomFreeShippingBarProps, HulkFormBuilderProps, HulkProductOptionsProps, IconListHozProps, IconListItemProps$1 as IconListItemProps, IconListProps$1 as IconListProps, IconProps, ImageComparisonItem, ImageDetectionProps, ImageProps, ImgProps, InfiniteOptionsProps, InputProps, InstafeedProps, InstasellShoppableInstagramProps, JudgemeReviewsProps, JunipProductReviewsUgcProps, KachingBundlesProps, KachingSubscriptionsAppProps, KingProductOptionsProps, KiteFreeGiftDiscountProps, KlarnaMessagingProps, KlaviyoProps, KoalaBundleQuantityDiscountProps, LaiProductReviewsProps, LineProps, LinkProps, LoloyalLoyaltyReferralsProps, LoopSubscriptionsProps, LooxReviewsProps, MarqueeItemProps, MarqueeProps, MaxbundleProductBundlesProps, MbcBundleVolumeDiscountProps, MenuProps, MyappgurusProductReviewsProps, NewsletterProps, NotificationAPI, NotificationConfig, NotifyBackInStockPreOrderProps, ObjectFit$2 as ObjectFit, OkendoReviewsLoyaltyProps, OmnisendProps, OpinewProps, PaginationProps, ParcelPanelProps, PickyStoryProps, PostPurchaseAdvancedListProps, PostPurchaseButtonProps, PostPurchaseBuyerConsentProps, PostPurchaseCountdownTimerProps, PostPurchaseImageProps, PostPurchaseLineProps, PostPurchaseLinkProps, PostPurchaseProductDescriptionProps, PostPurchaseProductDiscountTagProps, PostPurchaseProductImagesProps, PostPurchaseProductOfferProps$1 as PostPurchaseProductOfferProps, PostPurchaseProductPriceBreakdownProps, PostPurchaseProductPriceProps, PostPurchaseProductQuantityProps, PostPurchaseProductSubscriptionProps, PostPurchaseProductTitleProps, PostPurchaseProductVariantsProps, PostPurchaseTextProps, PowerfulContactFormBuilderProps, PreorderNowPreOrderPqProps, PreorderNowWodPresaleProps, ProductBadgeProps, ProductBundleDiscountProps, ProductBundleItemDiscountProps, ProductButtonProps, ProductDescriptionProps, ProductImagesProps, ProductListProps, ProductListProps$1 as ProductListPropsV3, ProductOptionsCustomizerProps, ProductOptionsVariantOptionProps, ProductPriceProps, ProductPropertiesProps, ProductProps, ProductQuantityProps, ProductReviewsProps, ProductTagProps, ProductTitleProps, ProductVariantsProps, ProductViewMoreProps, PumperBundlesVolumeDiscountProps, PushOwlProps, QikifyUpsellProps, RapiBundleQuantityBreaksProps, RechargeSubscriptionsProps, RecurpaySubscriptionAppProps, ReleasitProps, RequestQuoteHidePriceProps, ReviewxpoProductReviewsAppProps, RivyoProps, RootProps$2 as RootProps, RowProps, RyviuProps, SealSubscriptionsProps, SegunoEmailMarketingProps, SelleasyProps, SeoantTrustBadgesIconProps, ShopPayButtonProps, ShopifyFormsProps, ShopifySubscriptionsProps, SimpleBundlesKitsProps, SkioSubscriptionsYcS20Props, SkuProps, SmartSearchBarAndFiltersProps, SproutPlantTreesGrowSalesProps, StampedProps, StellarDeliveryDatePickupProps, SubifySubscriptionsAppProps, SubmitButtonProps, TabItemProps, TabsProps, TagembedSocialPostReviewProps, TagshopShoppableVideosUgcProps, TeeinblueProductPersonalizerProps, TextAreaProps, TextFieldProps, TextInputProps, TextProps, TextareaProps, TrustBadgesBearProps, TrustMeProps, TrustedsiteTrustBadgesProps, TrustooProps, TrustreviewsProductReviewsProps, TrustshopProductReviewsProps, UltimateSalesBoostProps, UnlimitedBundlesDiscountsProps, UppromoteAffiliateMarketingProps, VendorProps, VitalsProps, WcWishlistBackInStockProps, WhatmoreShoppableVideosreelProps, WideBundleProps, WiserProps, WishlistKingProps, WishlistPlusProps, YotpoLoyaltyProps, YotpoReviewsProps };