import { C as ContainerParameters, T as TextParameters } from '../../parameters-B8w5Q6Pp.mjs';
import { ComponentProps, ResolvedAssetFromItem, ViewPort } from '../../types/cskTypes.mjs';
import * as react from 'react';
import { FC } from 'react';
import { c as ContentAlignment$2, B as ButtonProps$1, b as ButtonVariant, C as ContainerProps$1, F as FooterProps$1, H as HeaderProps$1, I as IconLabelProps$1 } from '../../index-BaOoyonn.mjs';
import * as _uniformdev_assets from '@uniformdev/assets';
import { AssetParamValue } from '@uniformdev/assets';
import { LinkParamValue, AssetParamValue as AssetParamValue$1, RichTextParamValue } from '@uniformdev/canvas';
import { T as TextProps$1 } from '../../index-CrBZatTs.mjs';
import { UniformSlotProps } from '@uniformdev/next-app-router/component';
import { RichTextNode } from '@uniformdev/richtext';
import '@uniformdev/next-app-router';
import '@uniformdev/next-app-router-shared';

declare const _default$D: react.ComponentType<ComponentProps<ContainerParameters, ContainerSlots> & ContainerAdditionalProps & ContainerParameters>;

type ContainerAdditionalProps = {
    className?: string;
};
declare enum ContainerSlots {
    ContainerContent = "containerContent"
}
type ContainerProps = ComponentProps<ContainerParameters, ContainerSlots> & ContainerAdditionalProps;

declare const _default$C: react.ComponentType<AccordionProps & ContainerParameters>;

type AccordionParameters = ContainerParameters;
declare enum AccordionSlots {
    AccordionContent = "accordionContent",
    AccordionItems = "accordionItems"
}
type AccordionProps = ComponentProps<AccordionParameters, AccordionSlots>;

type AccordionItemParameters = Pick<ContainerParameters, 'backgroundColor' | 'spacing' | 'border'> & TextParameters;
type AccordionItemAdditionalProps = {
    className?: string;
};
declare enum AccordionItemSlots {
    AccordionItemContent = "accordionItemContent"
}
type AccordionItemProps = ComponentProps<AccordionItemParameters, AccordionItemSlots> & AccordionItemAdditionalProps;
declare const _default$B: react.ComponentType<ComponentProps<AccordionItemParameters, AccordionItemSlots> & AccordionItemAdditionalProps & Pick<ContainerParameters, "backgroundColor" | "border" | "spacing"> & TextParameters>;

declare const _default$A: react.ComponentType<BadgeProps & BadgeParameters>;

type BadgeParameters = {
    text?: string;
    textColor?: string;
    backgroundColor?: string;
    borderColor?: string;
    dotColor?: string;
    pill?: boolean;
    size?: string;
};
type BadgeProps = ComponentProps<BadgeParameters>;

declare const _default$z: react.ComponentType<BannerProps & ContainerParameters & {
    iconColor?: string;
    contentAlignment?: ContentAlignment$2;
    floating?: boolean;
}>;

declare enum BannerSlots {
    BannerContent = "bannerContent"
}
type BannerParameters = ContainerParameters & {
    iconColor?: string;
    contentAlignment?: ContentAlignment$2;
    floating?: boolean;
};
type BannerProps = ComponentProps<BannerParameters, BannerSlots>;

declare const _default$y: react.ComponentType<ComponentProps<ButtonParameters> & ButtonAdditionalProps & Omit<ButtonParameters, "icon"> & {
    icon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type ButtonParameters = {
    text?: string;
    link?: LinkParamValue;
    textColor?: string;
    textWeight?: string;
    textFont?: 'uppercase' | 'lowercase' | 'capitalize' | 'normal-case';
    textTransform?: string;
    buttonColor?: string;
    border?: string | ViewPort<string>;
    size?: string;
    icon?: AssetParamValue;
    test?: AssetParamValue;
    textSize?: ButtonProps$1['textSize'];
    iconPosition?: ButtonProps$1['iconPosition'];
    hoverButtonColor?: string;
    hoverTextColor?: string;
};
type ButtonAdditionalProps = {
    className?: string;
    onClick?: () => void;
};
type ButtonProps = ComponentProps<ButtonParameters> & ButtonAdditionalProps;

declare const _default$x: react.ComponentType<ComponentProps<ContainerParameters, CardSlots> & CardAdditionalProps & ContainerParameters>;

type CardAdditionalProps = {
    className?: string;
    contentClassName?: string;
};
type CardParameters = ContainerParameters;
declare enum CardVariants {
    BackgroundImage = "backgroundImage"
}
declare enum CardSlots {
    CardMedia = "cardMedia",
    CardContent = "cardContent"
}
type CardProps = ComponentProps<CardParameters, CardSlots> & CardAdditionalProps;

type CarouselParameters = ContainerParameters & {
    itemsPerPage?: string;
    gapX?: string;
};
declare enum CarouselSlots {
    Items = "carouselItems"
}
type CarouselProps = ComponentProps<CarouselParameters, CarouselSlots>;
declare const _default$w: react.ComponentType<CarouselProps & ContainerParameters & {
    itemsPerPage?: string;
    gapX?: string;
}>;

declare const ComponentEmptyPlaceholder: FC<ComponentEmptyPlaceholderProps & ComponentEmptyPlaceholderParameters>;

type ComponentEmptyPlaceholderParameters = unknown;
type ComponentEmptyPlaceholderProps = ComponentProps<ComponentEmptyPlaceholderParameters>;

type UniformDate = {
    datetime: string;
};
type CountdownParameters = {
    targetDate?: UniformDate;
    backgroundColor?: string;
    textColor?: string;
    border?: string | ViewPort<string>;
    size?: TextProps$1['size'];
};
declare enum CountdownSlots {
    CountdownComplete = "countdownComplete"
}
declare enum CountdownVariants {
    LabelsUnder = "labelsUnder"
}
type CountdownProps = ComponentProps<CountdownParameters, CountdownSlots>;
declare const _default$v: react.ComponentType<CountdownProps & CountdownParameters>;

type PrefixedKeys<T, Prefix extends string> = {
    [Key in keyof T as `${Prefix}${Capitalize<string & Key>}`]: T[Key];
};

declare enum ContentAlignment$1 {
    Left = "left",
    Center = "center",
    Right = "right"
}
type BaseButtonParameters = {
    text?: string;
    link?: LinkParamValue;
    textColor?: string;
    textWeight?: string;
    textFont?: 'uppercase' | 'lowercase' | 'capitalize' | 'normal-case';
    textTransform?: string;
    buttonColor?: string;
    border?: string | ViewPort<string>;
    size?: string;
    icon?: AssetParamValue;
    test?: AssetParamValue;
    textSize?: ButtonProps$1['textSize'];
    iconPosition?: ButtonProps$1['iconPosition'];
    hoverButtonColor?: string;
    hoverTextColor?: string;
};
type BaseImageParameters = {
    image?: AssetParamValue;
    width?: number;
    height?: number;
    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
    overlayColor?: string;
    overlayOpacity?: string;
    contrastBaseColor?: string;
    border?: string | ViewPort<string>;
    priority?: boolean;
    unoptimized?: boolean;
    fill?: boolean;
};
type EyebrowTitleTextParameters = PrefixedKeys<TextParameters, 'eyebrowTitle'>;
type TitleTextParameters = PrefixedKeys<TextParameters, 'title'>;
type DescriptionTextParameters = PrefixedKeys<TextParameters, 'description'>;
type PrimaryButtonParameters = PrefixedKeys<BaseButtonParameters, 'primaryButton'> & {
    primaryButtonVariant?: ButtonVariant;
};
type SecondaryButtonParameters = PrefixedKeys<BaseButtonParameters, 'secondaryButton'> & {
    secondaryButtonVariant?: ButtonVariant;
};
type ImageParameters$1 = PrefixedKeys<Omit<BaseImageParameters, 'image'>, 'image'> & Pick<BaseImageParameters, 'image'>;
type DemoHeroParameters = ContainerParameters & {
    contentAlignment?: ContentAlignment$1;
} & EyebrowTitleTextParameters & TitleTextParameters & DescriptionTextParameters & PrimaryButtonParameters & SecondaryButtonParameters & ImageParameters$1;
type FixedHeroParameters = {
    textColor?: string;
    overlayAutoTint?: string;
} & DemoHeroParameters;
type FlexibleHeroParameters = DemoHeroParameters;
declare enum DemoHeroVariants {
    Columns = "columns",
    ColumnsReverse = "columnsReverse"
}
declare enum FlexibleHeroSlots {
    FlexibleHeroContent = "flexibleHeroContent",
    FlexibleHeroCta = "flexibleHeroCta"
}
type FixedHeroProps = ComponentProps<FixedHeroParameters>;
type FlexibleHeroProps = ComponentProps<FlexibleHeroParameters, FlexibleHeroSlots>;
declare const DemoHero: {
    FixedHero: react.ComponentType<FixedHeroProps & Omit<FixedHeroParameters, "image" | "primaryButtonIcon"> & {
        image?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
        primaryButtonIcon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
    }>;
    FlexibleHero: react.ComponentType<FlexibleHeroProps & Omit<DemoHeroParameters, "image" | "primaryButtonIcon"> & {
        image?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
        primaryButtonIcon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
    }>;
};

declare const _default$u: react.ComponentType<DividerProps & DividerParameters>;

type DividerParameters = {
    color?: string;
    thickness?: '1px' | '2px' | '3px' | '4px' | '5px' | '6px' | '7px' | '8px' | '9px' | '10px';
    width?: '100%' | '90%' | '80%' | '70%' | '60%' | '50%' | '40%' | '30%' | '20%' | '10%';
    alignment?: 'start' | 'center' | 'end';
};
type DividerProps = ComponentProps<DividerParameters>;

declare const _default$t: react.ComponentType<ComponentProps<FlexParameters, FlexSlots> & FlexAdditionalProps & ContainerParameters & {
    direction?: ("col" | "row" | "row-reverse" | "col-reverse") | ViewPort<"col" | "row" | "row-reverse" | "col-reverse">;
    justifyContent?: ("center" | "end" | "start" | "between") | ViewPort<"center" | "end" | "start" | "between">;
    gap?: ("2" | "8" | "16") | ViewPort<"2" | "8" | "16">;
    alignItems?: ("center" | "stretch" | "end" | "start") | ViewPort<"center" | "stretch" | "end" | "start">;
    wrap?: ("nowrap" | "wrap" | "wrap-reverse") | ViewPort<"nowrap" | "wrap" | "wrap-reverse">;
}>;

type Direction = 'row' | 'row-reverse' | 'col' | 'col-reverse';
type Justify = 'start' | 'end' | 'center' | 'between';
type AvailableGap = '2' | '8' | '16';
type Align$2 = 'start' | 'end' | 'center' | 'stretch';
type Wrap = 'nowrap' | 'wrap' | 'wrap-reverse';
type FlexAdditionalProps = {
    className?: string;
    wrapperClassName?: string;
};
type FlexParameters = ContainerParameters & {
    direction?: Direction | ViewPort<Direction>;
    justifyContent?: Justify | ViewPort<Justify>;
    gap?: AvailableGap | ViewPort<AvailableGap>;
    alignItems?: Align$2 | ViewPort<Align$2>;
    wrap?: Wrap | ViewPort<Wrap>;
};
declare enum FlexSlots {
    FlexItem = "flexItem"
}
type FlexProps = ComponentProps<FlexParameters, FlexSlots> & FlexAdditionalProps;

declare const _default$s: react.ComponentType<FlexItemProps & FlexItemParameters>;

type AvailableAlignSelf = 'auto' | 'start' | 'end' | 'center' | 'stretch';
type AvailableShrink = '0' | '1';
type FlexItemParameters = {
    displayName?: string;
    alignSelf?: AvailableAlignSelf | ViewPort<AvailableAlignSelf>;
    shrink?: AvailableShrink;
};
declare enum FlexItemSlots {
    Inner = "inner"
}
type FlexItemProps = ComponentProps<FlexItemParameters, FlexItemSlots>;

declare const _default$r: react.ComponentType<FooterProps & Omit<ContainerProps$1, "content" | "height"> & {
    logo?: react.ReactNode;
    copyright?: react.ReactNode;
    content?: react.ReactNode;
}>;

type FooterParameters = FooterProps$1;
declare enum FooterSlots {
    FooterLogo = "footerLogo",
    FooterCopyright = "footerCopyright",
    FooterContent = "footerContent"
}
type FooterProps = ComponentProps<FooterParameters, FooterSlots>;

declare const _default$q: react.ComponentType<SimpleFooterProps & Omit<SimpleFooterParameters, "logo"> & {
    logo?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type SimpleFooterParameters = {
    logo?: AssetParamValue$1;
    copyright?: RichTextParamValue;
    footerLinkSectionTitle?: string;
    links?: {
        title: string;
        link: LinkParamValue;
    }[];
};
type SimpleFooterProps = ComponentProps<SimpleFooterParameters>;

declare const _default$p: react.ComponentType<ComponentProps<GridParameters, GridSlots> & GridAdditionalProps & ContainerParameters & {
    columnsCount?: ("1" | "2" | "3" | "12" | "9" | "8" | "4" | "5" | "6" | "7" | "10" | "11") | ViewPort<"1" | "2" | "3" | "12" | "9" | "8" | "4" | "5" | "6" | "7" | "10" | "11">;
    gapY?: ("2" | "8" | "16") | ViewPort<"2" | "8" | "16">;
    gapX?: ("2" | "8" | "16") | ViewPort<"2" | "8" | "16">;
    alignItems?: ("center" | "stretch" | "end" | "start" | "baseline") | ViewPort<"center" | "stretch" | "end" | "start" | "baseline">;
}>;

type AvailableGridColumnsCount = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
type AvailableGridGap = '2' | '8' | '16';
type Align$1 = 'start' | 'end' | 'center' | 'baseline' | 'stretch';
type GridAdditionalProps = {
    className?: string;
};
type GridParameters = ContainerParameters & {
    columnsCount?: AvailableGridColumnsCount | ViewPort<AvailableGridColumnsCount>;
    gapY?: AvailableGridGap | ViewPort<AvailableGridGap>;
    gapX?: AvailableGridGap | ViewPort<AvailableGridGap>;
    alignItems?: Align$1 | ViewPort<Align$1>;
};
declare enum GridSlots {
    GridInner = "gridInner"
}
type GridProps = ComponentProps<GridParameters, GridSlots> & GridAdditionalProps;

declare const _default$o: react.ComponentType<ComponentProps<GridItemParameters, GridItemSlots> & GridItemAdditionalProps & GridItemParameters>;

type AvailableGridItemColumnsCount = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
type AvailableGridItemSpan = 'auto' | 'span-1' | 'span-2' | 'span-3' | 'span-4' | 'span-5' | 'span-6' | 'span-7' | 'span-8' | 'span-9' | 'span-10' | 'span-11' | 'span-12' | 'span-full';
type AvailableGridItemRowStart = '1' | '2' | '3' | '4' | '5' | '6';
type Align = 'start' | 'end' | 'center' | 'baseline' | 'stretch';
type GridItemAdditionalProps = {
    className?: string;
};
type GridItemParameters = {
    displayName?: string;
    columnStart?: AvailableGridItemColumnsCount | ViewPort<AvailableGridItemColumnsCount>;
    columnSpan?: AvailableGridItemSpan | ViewPort<AvailableGridItemSpan>;
    rowStart?: AvailableGridItemRowStart | ViewPort<AvailableGridItemRowStart>;
    rowSpan?: AvailableGridItemSpan | ViewPort<AvailableGridItemSpan>;
    alignSelf?: Align | ViewPort<Align>;
};
declare enum GridItemSlots {
    Inner = "inner"
}
type GridItemProps = ComponentProps<GridItemParameters, GridItemSlots> & GridItemAdditionalProps;

declare const _default$n: react.ComponentType<HeaderProps & HeaderParameters>;

type HeaderParameters = Omit<HeaderProps$1, 'sticky'>;
declare enum HeaderSlots {
    HeaderLeftContent = "headerLeftContent",
    HeaderCenterContent = "headerCenterContent",
    HeaderRightContent = "headerRightContent"
}
declare enum HeaderVariants {
    Sticky = "sticky"
}
type HeaderProps = ComponentProps<HeaderParameters, HeaderSlots>;

declare const _default$m: react.ComponentType<SimpleHeaderProps & Omit<SimpleHeaderParameters, "logo"> & {
    logo?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type SimpleHeaderParameters = {
    logo?: AssetParamValue$1;
    color?: string;
    links?: {
        title: string;
        link: LinkParamValue;
    }[];
    backgroundColor?: string;
    textColor?: string;
    hoverTextColor?: string;
};
type SimpleHeaderProps = ComponentProps<SimpleHeaderParameters>;

declare const _default$l: react.ComponentType<IconLabelProps & Omit<IconLabelParameters, "icon"> & {
    icon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type IconLabelParameters = Omit<IconLabelProps$1, 'children'> & {
    icon?: AssetParamValue;
};
type IconLabelProps = ComponentProps<IconLabelParameters>;

declare const _default$k: react.ComponentType<ImageProps & Omit<ImageParameters, "image"> & {
    image?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type ImageParameters = {
    image?: AssetParamValue;
    width?: number;
    height?: number;
    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
    overlayColor?: string;
    overlayOpacity?: string;
    border?: string | ViewPort<string>;
    priority?: boolean;
    unoptimized?: boolean;
    fill?: boolean;
};
type ImageProps = ComponentProps<ImageParameters>;

type ImageGalleryParameters = ContainerParameters & {
    aspectRatio?: 'square' | 'video';
    items?: AssetParamValue;
};
type ImageGalleryAdditionalProps = {
    config?: {
        firstLineCount: number;
        secondLineCount: number;
        otherLinesCount: number;
    };
};
declare enum ImageGallerySlots {
    Items = "imageGalleryItems"
}
type ImageGalleryProps = ComponentProps<ImageGalleryParameters, ImageGallerySlots> & ImageGalleryAdditionalProps;
declare const _default$j: react.ComponentType<ComponentProps<ImageGalleryParameters, ImageGallerySlots> & ImageGalleryAdditionalProps & Omit<ImageGalleryParameters, "items"> & {
    items?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

declare const _default$i: react.ComponentType<LinkProps & LinkParameters>;

type LinkParameters = {
    displayName?: string;
    link?: LinkParamValue;
    openInNewTab?: boolean;
};
declare enum LinkSlots {
    LinkContent = "linkContent"
}
type LinkProps = ComponentProps<LinkParameters, LinkSlots>;

type ModalParameters = {
    maxWidth?: 'small' | 'medium' | 'large';
    backgroundColor?: string;
    closeIconColor?: string;
    disableCloseModalOnClickOutside?: boolean;
};
declare enum ModalSlots {
    Trigger = "trigger",
    ModalContent = "modalContent",
    ModalActions = "modalActions"
}
type ModalProps = ComponentProps<ModalParameters, ModalSlots>;
declare const _default$h: react.ComponentType<ModalProps & ModalParameters>;

type NavigationFlyoutParameters = TextParameters & {
    icon?: AssetParamValue;
    link?: LinkParamValue;
    backgroundColor?: string;
    border?: string | ViewPort<string>;
    caretIcon?: AssetParamValue;
    hoverEffect?: string | ViewPort<string>;
    className?: string;
};
declare enum NavigationFlyoutSlots {
    NavigationFlyoutLeftContent = "navigationFlyoutLeftContent",
    NavigationFlyoutRightContent = "navigationFlyoutRightContent"
}
type NavigationFlyoutProps = ComponentProps<NavigationFlyoutParameters, NavigationFlyoutSlots>;

declare const NavigationFlyout: (props: NavigationFlyoutProps) => react.JSX.Element;

type NavigationGroupParameters = TextParameters & {
    icon?: AssetParamValue;
    caretIcon?: AssetParamValue;
    link?: LinkParamValue;
    backgroundColor?: string;
    border?: string | ViewPort<string>;
    hoverEffect?: string | ViewPort<string>;
    className?: string;
};
declare enum NavigationGroupSlots {
    Links = "links"
}
type NavigationGroupProps = ComponentProps<NavigationGroupParameters, NavigationGroupSlots>;
declare const NavigationGroup: (props: NavigationGroupProps) => react.JSX.Element;

declare const _default$g: react.ComponentType<NavigationLinkProps & Omit<NavigationLinkParameters, "icon"> & {
    icon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type NavigationLinkParameters = TextParameters & {
    icon?: AssetParamValue;
    link?: LinkParamValue;
    activeState?: boolean;
    hoverEffect?: string | ViewPort<string>;
    className?: string;
};
type NavigationLinkProps = ComponentProps<NavigationLinkParameters>;

type NavigationMegaCategoryParameters = TextParameters & {
    icon?: AssetParamValue;
    caretIcon?: AssetParamValue;
    link?: LinkParamValue;
    backgroundColor?: string;
    border?: string | ViewPort<string>;
    hoverEffect?: string | ViewPort<string>;
    className?: string;
};
declare enum NavigationMegaCategorySlots {
    CategoryPanel = "categoryPanel"
}
type NavigationMegaCategoryProps = ComponentProps<NavigationMegaCategoryParameters, NavigationMegaCategorySlots>;
declare const _default$f: react.ComponentType<NavigationMegaCategoryProps & Omit<NavigationMegaCategoryParameters, "icon" | "caretIcon"> & {
    icon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
    caretIcon?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

declare const _default$e: react.ComponentType<ComponentProps<PageParameters, CommonPageSlots> & PageAdditionalProps & PageParameters>;

type PageAdditionalProps = {
    headerCustomRenderer?: UniformSlotProps['children'];
    contentCustomRenderer?: UniformSlotProps['children'];
    footerCustomRenderer?: UniformSlotProps['children'];
};
type PageParameters = {
    pageTitle?: string;
    backgroundColor?: string;
};
declare enum CommonPageSlots {
    PageContent = "pageContent",
    PageHeader = "pageHeader",
    PageFooter = "pageFooter"
}
type PageProps = ComponentProps<PageParameters, CommonPageSlots> & PageAdditionalProps;

declare const _default$d: react.ComponentType<ReviewProps & ContainerParameters & {
    stars?: number;
    starsColor?: string;
    activeStarsColor?: string;
    showRatingLabel?: boolean;
}>;

type ReviewParameters = ContainerParameters & {
    stars?: number;
    starsColor?: string;
    activeStarsColor?: string;
    showRatingLabel?: boolean;
};
declare enum ReviewVariants {
    MultiColumn = "multiColumn"
}
declare enum ReviewSlots {
    ReviewImage = "reviewImage",
    ReviewPersonInfo = "reviewPersonInfo",
    ReviewContent = "reviewContent"
}
type ReviewProps = ComponentProps<ReviewParameters, ReviewSlots>;

declare const _default$c: react.ComponentType<ComponentProps<RichTextParameters> & RichTextAdditionalProps & RichTextParameters>;

type Size = 'sm' | 'base' | 'lg' | 'xl' | '2xl';
type RichTextAdditionalProps = {
    className?: string;
};
type RichTextParameters = {
    text?: RichTextNode;
    size?: Size;
    color?: string;
    font?: string;
    lineCountRestrictions?: string;
};

type RichTextProps = ComponentProps<RichTextParameters> & RichTextAdditionalProps;

declare const _default$b: react.ComponentType<SectionProps & ContainerParameters & {
    contentAlignment?: ContentAlignment;
}>;

declare enum ContentAlignment {
    Left = "left",
    Center = "center",
    Right = "right"
}
type SectionParameters = ContainerParameters & {
    contentAlignment?: ContentAlignment;
};
declare enum SectionVariants {
    Columns = "columns",
    ColumnsReverse = "columnsReverse"
}
declare enum SectionSlots {
    SectionContent = "sectionContent",
    SectionMedia = "sectionMedia",
    SectionCTA = "sectionCTA"
}
type SectionProps = ComponentProps<SectionParameters, SectionSlots>;

declare const _default$a: react.ComponentType<SpacerProps & SpacerParameters>;

type SpacerParameters = {
    size?: string;
};
declare enum SpacerVariants {
    Horizontal = "horizontal"
}
type SpacerProps = ComponentProps<SpacerParameters>;

declare const _default$9: react.ComponentType<TabProps & TabParameters>;

type TabParameters = {
    title?: string;
};
declare enum TabSlots {
    TabContent = "tabContent"
}
type TabProps = ComponentProps<TabParameters, TabSlots>;

declare const _default$8: react.ComponentType<TableProps & ContainerParameters & {
    size?: string;
    textColor?: string;
}>;

type TableParameters = ContainerParameters & {
    size?: string;
    textColor?: string;
};
declare enum TableSlots {
    TableHead = "tableHead",
    TableBody = "tableBody"
}
type TableProps = ComponentProps<TableParameters, TableSlots>;

declare const _default$7: react.ComponentType<TableCustomCellProps & TableCustomCellParameters>;

type TableCustomCellParameters = {
    alignment?: 'left' | 'center' | 'right';
};
declare enum TableCustomCellSlots {
    TableCustomCellContent = "tableCustomCellContent"
}
type TableCustomCellProps = ComponentProps<TableCustomCellParameters, TableCustomCellSlots>;

declare const _default$6: react.ComponentType<TableDataCellProps & TableDataCellParameters>;

type TableDataCellParameters = {
    value?: string;
};
type TableDataCellProps = ComponentProps<TableDataCellParameters>;

declare const _default$5: react.ComponentType<TableHeaderCellProps & TableHeaderCellParameters>;

type TableHeaderCellParameters = {
    value?: string;
};
type TableHeaderCellProps = ComponentProps<TableHeaderCellParameters>;

declare const _default$4: react.ComponentType<TableRowProps>;

type TableRowParameters = unknown;
type TableRowProps = ComponentProps<TableRowParameters>;

declare const _default$3: react.ComponentType<TestimonialProps & ContainerParameters>;

declare enum TestimonialVariants {
    WithLargeAvatar = "withLargeAvatar",
    WithOverlappingImage = "withOverlappingImage"
}
type TestimonialParameters = ContainerParameters;
declare enum TestimonialSlots {
    TestimonialSecondaryImage = "testimonialSecondaryImage",
    TestimonialContent = "testimonialContent",
    TestimonialPrimaryImage = "testimonialPrimaryImage",
    TestimonialAuthor = "testimonialAuthor"
}
type TestimonialProps = ComponentProps<TestimonialParameters, TestimonialSlots>;

declare const _default$2: react.ComponentType<TextProps & TextParameters>;

type TextProps = ComponentProps<TextParameters>;

type ThemeSwitcherParameters = {
    iconColor?: string;
};
type ThemeSwitcherProps = ComponentProps<ThemeSwitcherParameters>;
declare const _default$1: react.ComponentType<ThemeSwitcherProps & ThemeSwitcherParameters>;

declare const _default: react.ComponentType<VideoProps & Omit<VideoParameters, "video" | "placeholderImage"> & {
    video?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
    placeholderImage?: ResolvedAssetFromItem<_uniformdev_assets.AssetParamValueItem>[] | undefined;
}>;

type VideoParameters = {
    video?: AssetParamValue;
    placeholderImage?: AssetParamValue;
    autoPlay?: boolean;
    lazyLoad?: boolean;
    loop?: boolean;
    controls?: boolean;
    muted?: boolean;
    overlayColor?: string;
    overlayOpacity?: string;
    border?: string | ViewPort<string>;
};
type VideoProps = ComponentProps<VideoParameters>;

export { _default$C as Accordion, _default$B as AccordionItem, type AccordionItemParameters, type AccordionItemProps, AccordionItemSlots, type AccordionParameters, type AccordionProps, AccordionSlots, _default$A as Badge, type BadgeParameters, type BadgeProps, _default$z as Banner, ContentAlignment$2 as BannerContentAlignment, type BannerParameters, type BannerProps, BannerSlots, _default$y as Button, type ButtonParameters, type ButtonProps, _default$x as Card, type CardParameters, type CardProps, CardSlots, CardVariants, _default$w as Carousel, type CarouselParameters, type CarouselProps, CarouselSlots, CommonPageSlots, ComponentEmptyPlaceholder, type ComponentEmptyPlaceholderParameters, type ComponentEmptyPlaceholderProps, _default$D as Container, ContainerParameters, type ContainerProps, ContainerSlots, _default$v as Countdown, type CountdownParameters, type CountdownProps, CountdownSlots, CountdownVariants, DemoHero, ContentAlignment$1 as DemoHeroContentAlignment, DemoHeroVariants, _default$u as Divider, type DividerParameters, type DividerProps, type FixedHeroParameters, type FixedHeroProps, _default$t as Flex, _default$s as FlexItem, type FlexItemParameters, type FlexItemProps, type FlexParameters, type FlexProps, type FlexibleHeroParameters, type FlexibleHeroProps, FlexibleHeroSlots, _default$r as Footer, type FooterParameters, type FooterProps, FooterSlots, _default$p as Grid, _default$o as GridItem, type GridItemParameters, type GridItemProps, GridItemSlots, type GridParameters, type GridProps, GridSlots, _default$n as Header, type HeaderParameters, type HeaderProps, HeaderSlots, HeaderVariants, _default$l as IconLabel, type IconLabelParameters, type IconLabelProps, _default$k as Image, _default$j as ImageGallery, type ImageGalleryParameters, type ImageGalleryProps, ImageGallerySlots, type ImageParameters, type ImageProps, _default$i as Link, type LinkParameters, type LinkProps, LinkSlots, _default$h as Modal, type ModalParameters, type ModalProps, ModalSlots, NavigationFlyout, type NavigationFlyoutParameters, type NavigationFlyoutProps, NavigationGroup, type NavigationGroupParameters, type NavigationGroupProps, _default$g as NavigationLink, type NavigationLinkParameters, type NavigationLinkProps, _default$f as NavigationMegaCategory, type NavigationMegaCategoryParameters, type NavigationMegaCategoryProps, NavigationMegaCategorySlots, _default$e as Page, type PageParameters, type PageProps, _default$d as Review, type ReviewParameters, type ReviewProps, ReviewSlots, ReviewVariants, _default$c as RichText, type RichTextParameters, type RichTextProps, _default$b as Section, ContentAlignment as SectionContentAlignment, type SectionParameters, type SectionProps, SectionSlots, SectionVariants, _default$q as SimpleFooter, type SimpleFooterParameters, type SimpleFooterProps, _default$m as SimpleHeader, type SimpleHeaderParameters, type SimpleHeaderProps, _default$a as Spacer, type SpacerParameters, type SpacerProps, SpacerVariants, _default$9 as Tab, type TabParameters, type TabProps, TabSlots, _default$8 as Table, _default$7 as TableCustomCell, type TableCustomCellParameters, type TableCustomCellProps, TableCustomCellSlots, _default$6 as TableDataCell, type TableDataCellParameters, type TableDataCellProps, _default$5 as TableHeaderCell, type TableHeaderCellParameters, type TableHeaderCellProps, type TableParameters, type TableProps, _default$4 as TableRow, type TableRowProps, TableSlots, _default$3 as Testimonial, type TestimonialParameters, type TestimonialProps, TestimonialSlots, TestimonialVariants, _default$2 as Text, TextParameters, type TextProps, _default$1 as ThemeSwitcher, type ThemeSwitcherParameters, type ThemeSwitcherProps, _default as Video, type VideoParameters, type VideoProps };