@levo-so/studio 0.1.81 → 0.1.83

package/dist/index.d.ts

@@ -1,22 +1,2561 @@
-export * from './blockSmith';
-export * from './bridge';
-export * from './components';
-export * from './components/backgroundPresets/exports';
-export { default as IntegrationFilters } from './components/integrationFilters/IntegrationFilters';
-export * from './components/registerModal/RegisterModal';
-export * from './constants/animation';
-export * from './constants/authentication';
-export * from './contentEngine';
-export * from './context/ForumContext';
-export * from './core';
-export * from './elements';
-export * from './hooks';
-export * from './interfaces';
-export * from './pixel/constants/colorOptions';
-export * from './pixel/optionsMap';
-export * from './pixel/propertyMap';
-export * from './providers';
-export * from './theme/defaultTheme';
-export * from './utils';
-export * from './utils/colorUtils';
-//# sourceMappingURL=index.d.ts.map
+import { Accordion } from 'radix-ui';
+import { Avatar as Avatar_2 } from 'radix-ui';
+import { ComponentType } from 'react';
+import { DayPicker } from 'react-day-picker';
+import { default as default_2 } from 'react';
+import { default as default_3 } from 'embla-carousel-react';
+import { FormVariantType } from '@levo-so/react-collection';
+import { ForwardRefExoticComponent } from 'react';
+import { IComment } from '@levo-so/core';
+import { IContactInfo } from '@levo-so/core';
+import { IFaviconMediaObject } from '@levo-so/core';
+import { IField } from '@levo-so/core';
+import { IForum } from '@levo-so/core';
+import { IForumJoinRequest } from '@levo-so/core';
+import { IForumPost } from '@levo-so/core';
+import { ILemaCollection } from '@levo-so/core';
+import { ILevoClient } from '@levo-so/core';
+import { ILevoFormContext } from '@levo-so/react-collection';
+import { ILevoMembership } from '@levo-so/core';
+import { IMedia } from '@levo-so/core';
+import { IMediaObject } from '@levo-so/core';
+import { IMeta } from '@levo-so/core';
+import { IResponseMultiple } from '@levo-so/core';
+import { IResponseSingle } from '@levo-so/core';
+import { IWorkspace } from '@levo-so/core';
+import { JSX } from 'react/jsx-runtime';
+import { LazyExoticComponent } from 'react';
+import { LevoError } from '@levo-so/core';
+import { LevoQuery } from '@levo-so/core';
+import { MotionProps } from 'motion/react';
+import { Popover } from 'radix-ui';
+import * as React_2 from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { Stripe } from '@stripe/stripe-js';
+import { Tabs } from 'radix-ui';
+import { Tooltip as Tooltip_2 } from 'radix-ui';
+import { UseEmblaCarouselType } from 'embla-carousel-react';
+
+export declare const AccordionContent: WithBlockPropsComponent<BaseAccordionContentProps>;
+
+export declare const AccordionItem: WithBlockPropsComponent<BaseAccordionItemProps>;
+
+export declare const AccordionRoot: WithBlockPropsComponent<BaseAccordionRootProps & {
+collapsible?: boolean;
+}>;
+
+export declare const AccordionTrigger: WithBlockPropsComponent<BaseAccordionTriggerProps>;
+
+/**
+ * Alternate method values for quick checking
+ */
+export declare const ALTERNATE_METHOD_VALUES: ("linkedin" | "google" | "oauth" | "microsoft" | "otp" | "whatsapp" | "magiclink" | "password")[];
+
+/**
+ * Alternate authentication methods (OAuth providers)
+ */
+export declare const ALTERNATIVE_AUTH_METHODS: IAuthenticationOption[];
+
+/** Animation configuration interface */
+export declare interface AnimationConfig {
+    entry?: EntryAnimationConfig;
+    exit?: MutableDeep<MotionProps["exit"]>;
+    whileHover?: AnimationProperties & {
+        transition?: TransitionConfig;
+    };
+    scroll?: ScrollAnimationConfig;
+}
+
+/** Animation transform properties */
+export declare interface AnimationProperties {
+    opacity?: number;
+    scale?: number;
+    rotate?: number;
+    rotateX?: number;
+    rotateY?: number;
+    x?: number;
+    y?: number;
+    skewX?: number;
+    skewY?: number;
+}
+
+declare type AuthenticationMethod = (typeof IMembershipAuthenticationMethods)[number];
+
+/**
+ * All available authentication options
+ */
+export declare const AuthenticationOptions: IAuthenticationOption[];
+
+export declare const AuthProvider: React.FC<{
+    children: React.ReactNode;
+    workspace: IWorkspace | null;
+    authOverride?: IAuthOverride | null;
+}>;
+
+export declare function Avatar({ className, ...props }: React_2.ComponentProps<typeof Avatar_2.Root>): JSX.Element;
+
+export declare function AvatarFallback({ className, isActive, ...props }: React_2.ComponentProps<typeof Avatar_2.Fallback> & {
+    isActive?: boolean;
+}): JSX.Element;
+
+export declare function AvatarFallbackV2({ className, ...props }: React_2.ComponentProps<typeof Avatar_2.Fallback>): JSX.Element;
+
+export declare function AvatarImage({ className, isActive, ...props }: React_2.ComponentProps<typeof Avatar_2.Image> & {
+    isActive?: boolean;
+}): JSX.Element;
+
+export declare function AvatarImageV2({ className, ...props }: React_2.ComponentProps<typeof Avatar_2.Image>): JSX.Element;
+
+export declare interface BackgroundEffectConfig {
+    type: "beams" | "dots" | "grid" | "gradient" | "waves";
+    colors?: {
+        primary?: string;
+        secondary?: string;
+        accent?: string;
+    };
+    settings?: {
+        size?: number;
+        spacing?: number;
+        direction?: string;
+        opacity?: number;
+        amplitude?: number;
+        frequency?: number;
+        speed?: number;
+        isInteractive?: boolean;
+        rows?: number;
+        cols?: number;
+        gridSize?: number;
+        hoverColor?: string;
+        lineWidth?: number;
+    };
+}
+
+export declare const BackgroundEffects: default_2.FC<BackgroundEffectsProps>;
+
+declare interface BackgroundEffectsProps {
+    config?: BackgroundEffectConfig;
+    presetId?: string;
+}
+
+export declare interface BackgroundPreset {
+    id: string;
+    name: string;
+    description?: string;
+    category: "minimal" | "dynamic" | "interactive" | "custom";
+    effect: BackgroundEffectConfig;
+    thumbnail?: string;
+}
+
+declare interface BaseAccordionContentProps extends BaseElementProps, Omit<React_2.ComponentPropsWithoutRef<typeof Accordion.Content>, "content"> {
+}
+
+declare interface BaseAccordionItemProps extends BaseElementProps, Omit<React_2.ComponentPropsWithoutRef<typeof Accordion.Item>, "content"> {
+}
+
+declare interface BaseAccordionRootProps extends BaseElementProps, Omit<TypeAccordionComponentProps, "content"> {
+}
+
+declare interface BaseAccordionTriggerProps extends BaseElementProps, Omit<React_2.ComponentPropsWithoutRef<typeof Accordion.Trigger>, "content"> {
+}
+
+export declare const BaseBlogContent: {
+    ({ className, content, config, styles, elementKey, generatedClassName, ref, ...rest }: BaseBlogContentProps): JSX.Element | null;
+    displayName: string;
+};
+
+export declare interface BaseBlogContentProps extends BaseElementProps, Omit<default_2.HTMLAttributes<HTMLDivElement>, "content"> {
+    ref?: default_2.Ref<HTMLDivElement>;
+}
+
+declare interface BaseBoxProps extends BaseElementProps, Omit<default_2.HTMLAttributes<HTMLDivElement>, "content"> {
+}
+
+export declare const BaseButton: React_2.ForwardRefExoticComponent<BaseButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare interface BaseButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, Omit<BaseElementProps, "content"> {
+    loadingText?: string;
+    isLoading?: boolean;
+}
+
+export declare const BaseContainer: ForwardRefExoticComponent<BaseContainerProps & RefAttributes<HTMLDivElement>>;
+
+declare interface BaseContainerProps extends BaseElementProps, Omit<React.HTMLAttributes<HTMLDivElement>, "content"> {
+}
+
+/**
+ * Base props interface for all studio elements
+ *
+ * These props are automatically injected by the withBlockProps HOC
+ * and provide access to element configuration, styling, and content
+ */
+declare interface BaseElementProps {
+    elementKey: string;
+    styles?: IStyles;
+    config?: IFieldConfig;
+    content?: any;
+    generatedClassName?: string;
+}
+
+export declare const BaseHeading: ForwardRefExoticComponent<BaseHeadingProps & RefAttributes<HTMLHeadingElement>>;
+
+declare interface BaseHeadingProps extends BaseElementProps, Omit<React.HTMLAttributes<HTMLHeadingElement>, "content"> {
+}
+
+declare type BaseIconProps = IconProps & HTMLElementProps & {
+    noElementKey?: boolean;
+};
+
+declare interface BaseIframeProps extends BaseElementProps, Omit<default_2.HTMLAttributes<HTMLDivElement>, "content"> {
+}
+
+declare type BaseImageProps = ImageProps & HTMLImageProps;
+
+declare interface BaseLinkProps extends BaseElementProps, Omit<React.HTMLAttributes<HTMLAnchorElement>, "content"> {
+}
+
+declare interface BaseMediaProps extends BaseElementProps {
+    alt: string;
+    media?: MediaContent_2;
+}
+
+declare interface BasePopoverContentProps extends BaseElementProps, Omit<TypePopoverContentComponentProps, "content"> {
+}
+
+declare interface BasePopoverTriggerProps extends BaseElementProps, Omit<TypePopoverTriggerComponentProps, "content"> {
+}
+
+export declare const BaseSection: default_2.ForwardRefExoticComponent<BaseSectionProps & default_2.RefAttributes<HTMLElement>>;
+
+declare interface BaseSectionProps extends BaseElementProps, Omit<default_2.HTMLAttributes<HTMLElement>, "content"> {
+}
+
+declare interface BaseTabsContentProps extends BaseElementProps, Omit<TypeTabsContentComponentProps, "content"> {
+    ref?: React_2.Ref<React_2.ElementRef<typeof Tabs.Content>>;
+}
+
+declare interface BaseTabsListProps extends BaseElementProps, Omit<TypeTabsListComponentProps, "content"> {
+    ref?: React_2.Ref<React_2.ElementRef<typeof Tabs.List>>;
+}
+
+declare interface BaseTabsTriggerProps extends BaseElementProps, Omit<TypeTabsTriggerComponentProps, "content"> {
+    ref?: React_2.Ref<React_2.ElementRef<typeof Tabs.Trigger>>;
+}
+
+export declare const BaseTypography: default_2.ForwardRefExoticComponent<BaseTypographyProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface BaseTypographyProps extends BaseElementProps, Omit<default_2.HTMLAttributes<HTMLDivElement>, "content"> {
+}
+
+export declare const BaseUserMenu: React_2.FC<BaseUserMenuProps>;
+
+export declare interface BaseUserMenuProps extends React_2.HTMLAttributes<HTMLDivElement>, Omit<BaseElementProps, "content"> {
+}
+
+declare type BlockChildren = ReactNode;
+
+export declare type BlockComponent = ComponentType<ILevoBlockBaseProps<any>> | LazyExoticComponent<ComponentType<ILevoBlockBaseProps<any>>>;
+
+declare type BlockContextType = {
+    parsedBlockData?: IBlockInstance;
+    setParsedBlockData?: React.Dispatch<React.SetStateAction<IBlockInstance | undefined>>;
+    blockData?: IBlockInstance;
+    pageContext?: IPageContext;
+    blockContext?: IBlockContext;
+    isBuilder?: boolean;
+    workspace_id: string;
+    pageSource: IPage["source"];
+};
+
+export declare const BlockProvider: React.FC<{
+    children: React.ReactNode;
+    value: BlockContextType;
+}>;
+
+export declare const BlockSourceModuleList: readonly ["collection", "event", "blog", "community", "context", "form"];
+
+export declare class BlocksRegistry {
+    private static instance;
+    private blocks;
+    private categories;
+    private constructor();
+    static getInstance(): BlocksRegistry;
+    registerBlocks(blocks: IBlock[]): void;
+    registerCategories(categories: IBlockCategory[]): void;
+    registerBlockToStudio(block: IBlock): void;
+    registerBlocksToStudio(blocks: IBlock[]): void;
+    registerCategoriesToStudio(categories: IBlockCategory[]): void;
+    private setupExternalBlockListener;
+    getBlocksFromCategory(category: string): IBlock[];
+    getSingleBlock(key: string, version?: string): IBlock | null;
+    getCategories(): IBlockCategory[];
+    getAllBlocks(): IBlock[];
+}
+
+export declare const blocksRegistry: BlocksRegistry;
+
+export declare interface BlockTemplateOptions {
+    contentSkeleton: any;
+    blockFetchedContent: Record<string, any>;
+    blockSource?: IStudioSource;
+    pageContext?: Record<string, any>;
+}
+
+export declare const BlogContent: WithBlockPropsComponent<BaseBlogContentProps>;
+
+/**
+ * BookingConfirmation
+ *
+ * Displays confirmation after successful booking:
+ * - Success icon and message
+ * - Booking ID
+ * - Booking details (name, dates, amount)
+ * - Close button
+ */
+export declare const BookingConfirmation: default_2.FC<IBookingConfirmationProps>;
+
+/**
+ * BookingModal
+ *
+ * Multi-step modal for booking payment flow:
+ * 1. Loading: Creates booking from content
+ * 2. Summary: Shows booking details and "Pay Now" button
+ * 3. Confirmation: Shows success message after payment
+ *
+ * For free bookings (unit_amount = 0), skips payment and goes directly to confirmation.
+ */
+export declare const BookingModal: ({ isOpen, onClose, contentId, collectionKey }: BookingModalProps) => JSX.Element | null;
+
+export declare interface BookingModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    contentId: string;
+    collectionKey: string;
+}
+
+/**
+ * BookingSummary
+ *
+ * Displays booking details before payment:
+ * - Cover image (if available)
+ * - Instance label (booking name)
+ * - Date/time (if available)
+ * - Quantity and pricing
+ * - Pay Now button
+ */
+export declare const BookingSummary: default_2.FC<IBookingSummaryProps>;
+
+export declare const Box: WithBlockPropsComponent<BaseBoxProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Built-in background effect presets organized by category
+ */
+export declare const BUILT_IN_PRESETS: BackgroundPreset[];
+
+export declare const Button: WithBlockPropsComponent<BaseButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const Calendar: ({ className, classNames, showOutsideDays, captionLayout, formatters, components, ...props }: CalendarProps) => JSX.Element;
+
+export declare type CalendarProps = React_2.ComponentProps<typeof DayPicker>;
+
+export declare const Carousel: WithBlockPropsComponent<default_2.HTMLAttributes<HTMLDivElement> & CarouselProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare type CarouselApi = UseEmblaCarouselType[1];
+
+export declare const CarouselContent: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CarouselDotButton: default_2.ForwardRefExoticComponent<Omit<default_2.DetailedHTMLProps<default_2.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & default_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const CarouselDots: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CarouselItem: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CarouselNext: default_2.ForwardRefExoticComponent<BaseButtonProps & default_2.RefAttributes<HTMLButtonElement>>;
+
+declare type CarouselOptions = UseCarouselParameters[0];
+
+export declare const CarouselPrevious: default_2.ForwardRefExoticComponent<BaseButtonProps & default_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface CarouselProps extends BaseElementProps {
+    opts?: CarouselOptions;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+}
+
+/**
+ * CategoryFilter displays a list of selectable category pills for filtering forum posts.
+ * Fetches categories from the API and renders them as toggleable buttons.
+ */
+export declare const CategoryFilter: React.FC<ICategoryFilterProps>;
+
+export declare const colorOptions: {
+    readonly brand: {
+        readonly label: "Brand";
+        readonly value: "brand";
+        readonly css: "var(--color-brand)";
+    };
+    readonly brandForeground: {
+        readonly label: "Brand Foreground";
+        readonly value: "brandForeground";
+        readonly css: "var(--color-brand-foreground)";
+    };
+    readonly brandSecondary: {
+        readonly label: "Brand Secondary";
+        readonly value: "brandSecondary";
+        readonly css: "var(--color-brand-secondary)";
+    };
+    readonly brandSecondaryForeground: {
+        readonly label: "Brand Secondary Foreground";
+        readonly value: "brandSecondaryForeground";
+        readonly css: "var(--color-brand-secondary-foreground)";
+    };
+    readonly "text-1": {
+        readonly label: "Text 1";
+        readonly value: "text-1";
+        readonly css: "var(--color-text-1)";
+    };
+    readonly "text-2": {
+        readonly label: "Text 2";
+        readonly value: "text-2";
+        readonly css: "var(--color-text-2)";
+    };
+    readonly "text-3": {
+        readonly label: "Text 3";
+        readonly value: "text-3";
+        readonly css: "var(--color-text-3)";
+    };
+    readonly border: {
+        readonly label: "Border";
+        readonly value: "border";
+        readonly css: "var(--color-border)";
+    };
+    readonly "background-1": {
+        readonly label: "Background 1";
+        readonly value: "background-1";
+        readonly css: "var(--color-background-1)";
+    };
+    readonly "background-2": {
+        readonly label: "Background 2";
+        readonly value: "background-2";
+        readonly css: "var(--color-background-2)";
+    };
+    readonly "background-3": {
+        readonly label: "Background 3";
+        readonly value: "background-3";
+        readonly css: "var(--color-background-3)";
+    };
+    readonly page: {
+        readonly label: "Page";
+        readonly value: "page";
+        readonly css: "var(--color-page)";
+    };
+    readonly black: {
+        readonly label: "Black";
+        readonly value: "black";
+        readonly css: "#000000";
+    };
+    readonly white: {
+        readonly label: "White";
+        readonly value: "white";
+        readonly css: "#FFFFFF";
+    };
+    readonly "icon-primary": {
+        readonly label: "Icon Primary";
+        readonly value: "icon-primary";
+        readonly css: "var(--color-icon-primary)";
+    };
+    readonly "icon-secondary": {
+        readonly label: "Icon Secondary";
+        readonly value: "icon-secondary";
+        readonly css: "var(--color-icon-secondary)";
+    };
+};
+
+export declare const Comments: default_2.FC<{
+    forumKey: string;
+    post: IForumPost;
+    onCommentCountChange?: (delta: number) => void;
+}>;
+
+/**
+ * Absolutely positioned overlay shown over comments section
+ * when non-member cannot view comments in invite-only community
+ */
+export declare const CommentsRestrictionOverlay: default_2.FC<ICommentsRestrictionOverlayProps>;
+
+export declare const CommentStatusBadge: default_2.FC<{
+    comment: IComment;
+}>;
+
+export declare const Container: WithBlockPropsComponent<BaseContainerProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ContentHint = {
+    min_characters?: number;
+    min_words?: number;
+    max_characters?: number;
+    max_words?: number;
+    usecase?: ContentUsecase;
+};
+
+export declare type ContentUsecase = "main_title" | "sub_title" | "description" | "label" | "button" | "person_name" | "designation" | "testimonial" | "cta_button" | "price" | "currency" | "interval" | "feature" | "title" | "stat_number" | "stat_label" | "question" | "answer" | "category" | "date" | "reading_time" | "author" | "address" | "phone" | "email" | "link_url" | "link_text";
+
+export declare const convertKeysToPascalCase: (key: string) => string;
+
+export declare const CreateForumPost: default_2.FC<ICreateForumPostProps>;
+
+declare type CSSOption = {
+    label: string;
+    value: string;
+    css?: string;
+};
+
+export declare const cssOptionsMap: Partial<Record<CSSStyleKeys, {
+    options: CSSOptionsRecord;
+    parser?: (value: any) => ParseResult;
+}>>;
+
+export declare type CSSOptionsRecord = Record<string, CSSOption>;
+
+export declare type CSSStyleKeys = "font-size" | "font-weight" | "text-align" | "text-decoration" | "text-transform" | "line-height" | "letter-spacing" | "color" | "display" | "flex-direction" | "justify-content" | "align-items" | "column-gap" | "row-gap" | "gap" | "grid-template-columns" | "grid-template-rows" | "width" | "min-width" | "max-width" | "height" | "filter" | "min-height" | "max-height" | "object-fit" | "border-radius" | "border-style" | "border-width" | "border-top-width" | "border-right-width" | "border-bottom-width" | "border-left-width" | "border-color" | "background-color" | "background-size" | "background-position" | "box-shadow" | "padding" | "padding-top" | "padding-bottom" | "padding-left" | "padding-right" | "margin" | "margin-top" | "margin-bottom" | "margin-left" | "margin-right" | "opacity" | "font" | "background-image" | "overflow" | "overflow-x" | "overflow-y" | "-webkit-line-clamp" | "-webkit-box-orient" | "font-family" | "number_of_slides" | "background_video_overlay_color" | "background_video_position";
+
+export declare const DATA_ATTRIBUTES: {
+    readonly BLOCK: "data-levo-block-id";
+    readonly ELEMENT: "data-levo_element_key";
+    readonly ITEM: "data-levo_group_item";
+    readonly GROUP: "data-levo_group";
+};
+
+declare type DeepConfig<T> = T extends Array<infer U> ? IFieldConfig & {
+    [index: number]: DeepConfig<U>;
+} : T extends object ? IFieldConfig & {
+    [K in keyof T]: DeepConfig<T[K]>;
+} & {
+    [x: string]: IFieldConfig;
+} : IFieldConfig;
+
+declare type DeepStyles<T> = T extends Array<infer U> ? IStyles & {
+    [index: number]: DeepStyles<U>;
+} : T extends object ? {
+    [K in keyof T]: DeepStyles<T[K]>;
+} : IStyles;
+
+/** Default "from" state for entry/scroll animations */
+export declare const DEFAULT_FROM_STATE: AnimationProperties;
+
+export declare const DEFAULT_THEME: ITheme;
+
+/** Default transition config */
+export declare const DEFAULT_TRANSITION: TransitionConfig;
+
+/** Default viewport config for entry animations */
+export declare const DEFAULT_VIEWPORT: ViewportConfig;
+
+/** Default visible state - target for all animations */
+export declare const DEFAULT_VISIBLE_STATE: AnimationProperties;
+
+export declare const DEMO_SCHEMA: ILemaCollection;
+
+export declare const EditForm: WithBlockPropsComponent<BaseElementProps & {
+className?: string;
+initialValues?: Record<string, any>;
+theme?: ILevoFormContext["theme"];
+onSubmit?: (values: any) => void;
+isLoading?: boolean;
+}>;
+
+/** Entry animation configuration with from/to states */
+export declare interface EntryAnimationConfig {
+    from?: AnimationProperties;
+    to?: AnimationProperties;
+    transition?: TransitionConfig;
+    viewport?: ViewportConfig;
+}
+
+/**
+ * Extended props interface for useCommonProps return type
+ */
+export declare type ExtendedProps<P extends Record<string, unknown>> = P & {
+    elementKey: string;
+    config: unknown;
+    styles: unknown;
+    content: unknown;
+    generatedClassName: string;
+};
+
+export declare const fetchCollectionSchema: ({ levoClient, source, cookies, draft, }: {
+    levoClient: ILevoClient;
+    source: {
+        workspace_id: string;
+        collection_id: string;
+    };
+    cookies?: string;
+    draft?: boolean;
+}) => Promise<{
+    content: {
+        data: ILemaCollection | null;
+    };
+}>;
+
+export declare const fetchSource: ({ levoClient, source, workspace_id, slugs, params, cookies, draft, }: SourceFetchOptions) => Promise<IResponseMultiple | IResponseSingle | null>;
+
+/**
+ * Recursively searches content_schema for a field with matching key
+ */
+export declare const findFieldSchema: (contentSchema: IStudioWidget[] | undefined, fieldKey: string | undefined) => IStudioWidget | undefined;
+
+export declare const Form: WithBlockPropsComponent<BaseElementProps & {
+className?: string;
+initialValues?: Record<string, any>;
+theme?: ILevoFormContext["theme"];
+}>;
+
+export declare const FormInput: React_2.ForwardRefExoticComponent<IInputProps & React_2.RefAttributes<HTMLInputElement>>;
+
+export declare const FormTextarea: React_2.ForwardRefExoticComponent<ITextareaProps & React_2.RefAttributes<HTMLTextAreaElement>>;
+
+export declare const ForumPost: default_2.FC<{
+    post: IForumPost;
+    postDetailPageURLPattern?: string | null;
+    postListingPageURL?: string | null;
+    isRenderedSolo?: boolean;
+    actionsLoadingState?: IPostActionsLoadingState;
+    forumKey?: string;
+    wrapperStyles?: string;
+}>;
+
+/**
+ * Forum provider
+ */
+export declare const ForumProvider: default_2.FC<{
+    children: default_2.ReactNode;
+    forum: IForum | null;
+    isMember: boolean;
+    isLoadingMembership: boolean;
+    isInviteOnly: boolean;
+    canInteractWithPosts: boolean;
+    canInteractWithComments: boolean;
+    joinRequest?: IForumJoinRequest | null;
+    isJoinRequestPending?: boolean;
+    allowJoinRequests?: boolean;
+    submitJoinRequest?: (message?: string) => Promise<boolean>;
+    refreshMembershipStatus?: () => Promise<void>;
+}>;
+
+export declare const generateAccentColor: (oklch: OKLCHColor) => {
+    oklch: OKLCHColor;
+    hex: string;
+};
+
+export declare const generateDefaultContent: (contentSchema: any[]) => any;
+
+export declare const generateSchemaFromJSX: (jsx: string) => IBlock["content_schema"];
+
+/**
+ * Component Theme and Variant Style Generation
+ *
+ * This is the core function that transforms the component theme system into CSS.
+ * It generates styles for both default component styling and theme variants.
+ *
+ * CSS Selectors Generated:
+ * 1. [data-levo_element_type='ComponentName'] - Component default styles
+ * 2. .levo-variant-{groupId}-{variantId} - Theme variant styles
+ *
+ * Style Hierarchy:
+ * - Component defaults apply to all instances of that component type
+ * - Variant classes override defaults when selected via ThemeVariantSelector
+ * - Block-specific styles (from generateBlockStyles) have highest specificity
+ *
+ * Integration Points:
+ * - withBlockProps HOC generates the variant classes on elements
+ * - ThemeVariantSelector allows users to select variants in widget config
+ * - VariantGroupManager provides the theme editor interface
+ *
+ * @param theme - Complete theme configuration with component definitions
+ * @returns CSS string with component and variant selectors
+ */
+export declare const generateThemeStyles: (theme?: ITheme, device?: IPreviewDevice) => string;
+
+/**
+ * CSS Custom Properties Generation
+ *
+ * Converts primitive theme values (colors, fonts, sizes) into CSS custom
+ * properties that can be used throughout the application. These variables
+ * provide a foundation for consistent styling and easy theme switching.
+ *
+ * Generated variables are available as:
+ * - var(--color-brand) for theme colors
+ * - var(--font-heading) for theme fonts
+ * - var(--base-spacing) for theme sizes
+ * - var(--color-custom-{name}) for custom colors
+ *
+ * @param theme - Theme configuration object
+ * @returns Object mapping CSS property names to values
+ */
+export declare const generateThemeVariables: (theme: ITheme) => {
+    "--color-brand": string;
+    "--color-brand-foreground": string;
+    "--color-brand-secondary": string;
+    "--color-brand-secondary-foreground": string;
+    "--color-text-1": string;
+    "--color-text-2": string;
+    "--color-text-3": string;
+    "--color-page": string;
+    "--color-border": string;
+    "--color-background-1": string;
+    "--color-background-2": string;
+    "--color-background-3": string;
+    "--color-icon-primary": string;
+    "--color-icon-secondary": string;
+    "--font-heading": string;
+    "--font-body": string;
+    "--base-radius": string;
+    "--base-spacing": string;
+    "--base-font-size": string;
+    "--default-shadow": string;
+};
+
+/**
+ * Generates variant CSS classes from selected variants configuration
+ *
+ * @param configValue - The field configuration containing selectedVariants
+ * @returns Array of variant class names
+ */
+export declare const generateVariantClasses: (configValue: IFieldConfig | undefined) => string[];
+
+/**
+ * Get all available preset categories
+ */
+export declare function getAvailableCategories(): Array<BackgroundPreset["category"]>;
+
+/**
+ * Get the effect configuration from a preset ID
+ * This is the main mapping function from preset ID to effect config
+ */
+export declare const getEffectConfigFromPresetId: (presetId: string) => BackgroundEffectConfig | null;
+
+export declare const getInitialPageContent: ({ levoClient, pageData, site, querySlugs, urlSlugs, minifyResponse, cookies, draft, }: {
+    levoClient: ILevoClient;
+    pageData: IPageExpanded;
+    site: ISite;
+    querySlugs: Record<string, string>;
+    urlSlugs: string[];
+    minifyResponse?: boolean;
+    cookies?: string;
+    draft?: boolean;
+}) => Promise<{
+    parsedPageData: ILevoPageData;
+    transformedPageData: ILevoPageData;
+    context?: IPageDataContext;
+    notFound: boolean;
+    headCode: string;
+}>;
+
+/**
+ * Utility function to safely access nested object properties
+ *
+ * Handles dot-notation paths and array indices to extract values
+ * from deeply nested block data structures
+ *
+ * @param obj - The object to traverse
+ * @param path - Dot-notation path to the desired property
+ * @returns The value at the specified path or undefined if not found
+ *
+ * @example
+ * getNestedValue({ user: { profile: { name: 'John' } } }, 'user.profile.name') // 'John'
+ * getNestedValue({ items: [{ id: 1 }, { id: 2 }] }, 'items.0.id') // 1
+ */
+export declare const getNestedValue: <P = unknown>(obj: Record<string, unknown>, path: string) => P | undefined;
+
+export declare const getPageData: ({ levoClient, workspace, url, draft, visitorParams, cookies, }: {
+    levoClient: ILevoClient;
+    workspace: string;
+    url: string;
+    draft?: boolean;
+    visitorParams?: Record<string, unknown>;
+    cookies?: string;
+}) => Promise<IPageFromPath | null>;
+
+export declare const getPageSource: ({ levoClient, pageData, slugs, cookies, draft, }: {
+    levoClient: ILevoClient;
+    pageData: IPageExpanded;
+    slugs: Record<string, string>;
+    cookies?: string;
+    draft?: boolean;
+}) => Promise<{
+    pageContext: IPageContext;
+    pageNotFound: boolean;
+}>;
+
+/**
+ * Get presets by category
+ */
+export declare function getPresetsByCategory(category: BackgroundPreset["category"]): BackgroundPreset[];
+
+/**
+ * Calculate WCAG 2.0 contrast ratio between two OKLCH colors
+ * Returns a number where higher values indicate better contrast
+ * WCAG AA requires 4.5:1 for normal text, 3:1 for large text
+ * WCAG AAA requires 7:1 for normal text, 4.5:1 for large text
+ */
+export declare const getWcagContrast: (foreground: OKLCHColor, background: OKLCHColor) => number;
+
+export declare const GlobalSearch: React.FC<IGlobalSearchProps>;
+
+export declare type GroupHint = {
+    min_items?: number;
+    max_items?: number;
+};
+
+export declare const Heading: WithBlockPropsComponent<BaseHeadingProps & RefAttributes<HTMLHeadingElement>>;
+
+/**
+ * Convert hex color string to OKLCH object format
+ * Returns default black color for invalid input
+ */
+export declare const hexToOKLCH: (hexColor: string) => OKLCHColor;
+
+export declare interface HighlightRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+
+declare type HTMLElementProps = Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, keyof BaseElementProps>;
+
+declare type HTMLImageProps = Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "src" | "alt" | keyof BaseElementProps>;
+
+declare type HTMLImageProps_2 = Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "src" | "alt" | keyof BaseElementProps>;
+
+declare type HTMLVideoProps = Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "src" | keyof BaseElementProps>;
+
+declare interface IAuthActions {
+    setAuthState: (updates: Partial<IAuthState>) => void;
+    resetAuth: () => void;
+}
+
+/**
+ * Authentication method configuration object
+ */
+export declare interface IAuthenticationOption {
+    label: string;
+    value: AuthenticationMethod;
+    category: "primary" | "alternate";
+    [x: string]: unknown;
+}
+
+export declare interface IAuthOverride {
+    enabled: boolean;
+    isLoggedIn: boolean;
+    selectedAccount?: ILevoMembership.Account | null;
+}
+
+declare interface IAuthProviderInterface extends IAuthState, IAuthActions {
+}
+
+declare interface IAuthState {
+    isLoggedIn: boolean;
+    account: ILevoMembership.Account | null;
+    workspace: IWorkspace | null;
+    isAuthLoaded: boolean;
+    isAuthLoading: boolean;
+    isSignOutLoading: boolean;
+    isVerifying: boolean;
+}
+
+declare interface IBaseInputProps {
+    name: string;
+    id?: string;
+    value?: any;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    label?: string;
+    isRequired?: boolean;
+    error?: any;
+    touched?: any;
+    helperText?: string;
+    labelStyles?: string;
+    containerStyles?: string;
+    helperTextStyles?: string;
+}
+
+export declare interface IBlock {
+    category_id: string;
+    title: string;
+    key: string;
+    version: string;
+    prompt_description?: string;
+    content_schema: IStudioWidget[];
+    layouts: IBlockLayouts[];
+    source?: ({
+        required: boolean;
+        module: IStudioSource["module"];
+        type: "block";
+        field_key: string;
+    } | {
+        required: boolean;
+        module: IStudioSource["module"];
+        type: "page";
+    })[];
+}
+
+export declare interface IBlockCategory {
+    id: string;
+    title: string;
+    description: string;
+    media?: any[];
+}
+
+export declare type IBlockCategoryExpanded = IBlockCategory & {
+    block: IBlock;
+};
+
+export declare type IBlockContext = Record<string, IResponseMultiple>;
+
+export declare interface IBlockGenerationInfo {
+    id: string;
+    status: "pending" | "current" | null;
+}
+
+export declare interface IBlockInstance {
+    id: string;
+    workspace_id: string;
+    key: string;
+    version: string;
+    title: string;
+    status: string;
+    content: Record<string, any>;
+    source: IStudioSource[];
+    settings: {
+        [key: string]: any;
+        sources?: never;
+    };
+    layout: string | null;
+    category: string;
+    config: Record<string, IFieldConfig | Record<string, IFieldConfig>[]>;
+    styles: IElementStyle;
+    theme: Record<string, any>;
+    view_count: number;
+    impression_count: number;
+    page_count: number;
+    source_count: number;
+    generation_status: null | "current" | "pending";
+    created_at: string;
+    updated_at: string;
+    deleted_at: any;
+    site_version: "v1" | "v2";
+}
+
+export declare interface IBlockLayouts {
+    key: string;
+    title: string;
+    styles: IElementStyle;
+    content: any;
+    config: any;
+}
+
+declare interface IBookingConfirmationProps {
+    booking: IBookingRecord;
+    summary: IBookingSummaryData | null;
+    onClose: () => void;
+}
+
+declare interface IBookingRecord {
+    _id: string;
+    status: string;
+    paid: boolean;
+    unit_amount: number;
+    currency: string;
+    quantity: number;
+    instance_label?: string;
+}
+
+declare interface IBookingSummaryData {
+    _id: string;
+    instance_label: string;
+    cover_image: {
+        location: string;
+    } | null;
+    /** QR code image for check-in scanning */
+    qr_image: {
+        location: string;
+    } | null;
+    /** Invoice PDF file, null if not generated */
+    invoice: {
+        location: string;
+    } | null;
+    starts_at: string | null;
+    ends_at: string | null;
+    quantity: number;
+    currency: string;
+    unit_amount: number;
+    total_amount: number;
+}
+
+declare interface IBookingSummaryData_2 {
+    _id: string;
+    instance_label: string;
+    cover_image: {
+        location: string;
+    } | null;
+    starts_at: string | null;
+    ends_at: string | null;
+    quantity: number;
+    currency: string;
+    unit_amount: number;
+    total_amount: number;
+    status: string;
+    paid: boolean;
+}
+
+declare interface IBookingSummaryProps {
+    summary: IBookingSummaryData_2;
+    onPay: () => void;
+    isLoading: boolean;
+}
+
+export declare interface ICategoryFilterProps {
+    /** The forum key/slug to fetch categories for */
+    forumKey: string;
+    /** Currently selected category IDs */
+    selectedCategories: string[];
+    /** Callback when category selection changes */
+    onCategoryToggle: (categoryId: string) => void;
+    /** Optional className for the container */
+    className?: string;
+}
+
+declare interface ICommentsRestrictionOverlayProps {
+    communityName?: string;
+    className?: string;
+}
+
+/**
+ * Complete theme configuration for a single component type
+ *
+ * Combines default styles that apply to all instances of the component
+ * with variant groups that provide specific style options
+ *
+ * @example
+ * // Heading component theme
+ * {
+ *   defaultStyles: { fontFamily: "Inter", color: "#000" },
+ *   variantGroups: {
+ *     headingLevel: {
+ *       id: "headingLevel",
+ *       name: "Heading Level",
+ *       variants: {
+ *         h1: { fontSize: "32px", fontWeight: "bold" },
+ *         h2: { fontSize: "28px", fontWeight: "bold" }
+ *       }
+ *     }
+ *   }
+ * }
+ */
+export declare interface IComponentTheme {
+    defaultStyles?: IElementStyle;
+    variantGroups?: Record<string, IVariantGroupConfig>;
+}
+
+export declare const Icon: WithBlockPropsComponent<Omit<BaseIconProps, "ref"> & RefAttributes<HTMLElement>>;
+
+declare interface IconProps extends BaseElementProps, Omit<React.HTMLAttributes<HTMLElement>, "content"> {
+}
+
+declare interface ICreateForumPostProps {
+    forumKey: string;
+    onPostCreated?: (post: IForumPost) => void;
+}
+
+export declare type IElementStyle = Record<string, any>;
+
+export declare interface IFieldConfig {
+    selectedVariants?: Record<string, string>;
+    enabled?: boolean;
+    animation?: AnimationConfig;
+    form?: {
+        collection_id?: string;
+        submit_button_label?: string;
+        workspace_id?: string;
+        schema?: ILemaCollection;
+        hidden_fields?: string[];
+        form_variant?: FormVariantType;
+        redirect_url?: string;
+    };
+    filters?: {
+        schema?: ILemaCollection;
+        selected_fields?: string[];
+    };
+    action?: {
+        type: "page" | "external_link" | "email" | "phone" | "login" | "none";
+        value: string;
+        options: {
+            openInNewTab?: boolean;
+        };
+    };
+    button_icons?: {
+        left?: {
+            enabled?: boolean;
+        };
+        right?: {
+            enabled?: boolean;
+        };
+    };
+    heading?: {
+        level?: number;
+    };
+    backgroundVideo?: {
+        media?: IMediaObject;
+    };
+    backgroundEffects?: BackgroundEffectConfig;
+    backgroundPresetId?: string;
+    carousel?: {
+        autoScroll?: boolean;
+        loop?: boolean;
+        autoPlay?: boolean;
+        speed?: number;
+        time_per_slide?: number;
+        stopOnFocusIn?: boolean;
+        stopOnInteraction?: boolean;
+        stopOnMouseEnter?: boolean;
+        direction?: "ltr" | "rtl";
+    };
+    image?: {
+        high_priority?: boolean;
+        width?: string;
+        height?: string;
+        alt?: string;
+    };
+    media?: {
+        autoPlay?: boolean;
+        controls?: boolean;
+        muted?: boolean;
+        loop?: boolean;
+        poster?: IMediaObject;
+        high_priority?: boolean;
+        width?: string;
+        height?: string;
+        alt?: string;
+    };
+    custom_html?: {
+        before?: string;
+        after?: string;
+    };
+    custom_fields?: Record<string, unknown>;
+}
+
+/**
+ * Forum context
+ */
+declare interface IForumContext {
+    forum: IForum | null;
+    isMember: boolean;
+    isLoadingMembership: boolean;
+    isInviteOnly: boolean;
+    /** Whether user can interact with posts (upvote/downvote) */
+    canInteractWithPosts: boolean;
+    /** Whether user can interact with comments (reply/vote) */
+    canInteractWithComments: boolean;
+    /** Current user's pending join request, if any */
+    joinRequest: IForumJoinRequest | null;
+    /** Whether user has a pending join request */
+    isJoinRequestPending: boolean;
+    /** Whether the forum allows join requests */
+    allowJoinRequests: boolean;
+    /** Submit a join request for the current user */
+    submitJoinRequest: (message?: string) => Promise<boolean>;
+    /** Refresh membership status from the server */
+    refreshMembershipStatus: () => Promise<void>;
+}
+
+export declare const Iframe: WithBlockPropsComponent<BaseIframeProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface IGenerationStatusOverlay {
+    id: string;
+    rect: HighlightRect | null;
+    element: HTMLElement | null;
+    status: "pending" | "current";
+}
+
+declare interface IGlobalSearchProps {
+    variant?: "default" | "icon";
+    hideKeyboardKey?: boolean;
+}
+
+/**
+ * Group context interface for repeatable widget detection
+ */
+export declare interface IGroupContext {
+    isGroupItem: boolean;
+    groupKey?: string;
+    itemIndex?: number;
+    childKey?: string;
+    groupItemKey?: string;
+    sharedPath?: string;
+}
+
+export declare interface IInputProps extends IBaseInputProps {
+    onChange?: (e: React_2.ChangeEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React_2.FocusEvent<HTMLInputElement>) => void;
+    inputStyles?: string;
+    type?: string;
+    inputProps?: React_2.InputHTMLAttributes<HTMLInputElement>;
+    leftIcon?: React_2.ReactNode;
+    rightIcon?: React_2.ReactNode;
+    leftIconBoxStyles?: string;
+    rightIconBoxStyles?: string;
+    inputContainerStyles?: string;
+}
+
+declare interface IJoinRequestFormProps {
+    onSubmit: (message?: string) => Promise<boolean>;
+    isSubmitting: boolean;
+    error: string | null;
+    communityName?: string;
+    className?: string;
+}
+
+declare interface ILazyMotionProviderProps {
+    children: ReactNode;
+    /** Enforce m component usage - throws if motion component is used */
+    strict?: boolean;
+}
+
+export declare interface ILevoBlockBaseProps<ContentType = Record<string, any>> {
+    content: ContentType & {
+        [x: string]: any;
+    };
+    styles: DeepStyles<ContentType & {
+        [x: string]: any;
+    }>;
+    config: DeepConfig<ContentType & {
+        [x: string]: any;
+    }>;
+    id: string;
+}
+
+export declare interface ILevoBlockProps<ContentType = Record<string, any>> extends ILevoBlockBaseProps<ContentType> {
+    id: string;
+    block_key: string;
+    block_version: string;
+    settings: ISettingsType;
+    source: IStudioSource[];
+}
+
+export declare type ILevoPageData = Pick<IPageExpanded, "id" | "workspace_id" | "blocks" | "source" | "title" | "description" | "access" | "style_config">;
+
+export declare interface ILevoPageProps {
+    pageData: ILevoPageData;
+    parsedPageData: ILevoPageData;
+    isBuilder?: boolean;
+    context?: IPageDataContext;
+    blocks: Record<string, BlockComponent>;
+    workspace: IWorkspace;
+    site: ISite;
+    authOverride?: IAuthOverride | null;
+    /** Wrap page content in a Suspense boundary (needed for React.lazy blocks). Auto-enabled when isBuilder is true. */
+    enableSuspense?: boolean;
+}
+
+export declare interface ILocalizedPage {
+    id: string;
+    language: string;
+    title: string;
+    status?: "published" | "draft";
+    countries?: string[];
+    url?: string;
+}
+
+declare const Image_2: WithBlockPropsComponent<Omit<BaseImageProps, "ref"> & RefAttributes<HTMLImageElement>>;
+export { Image_2 as Image }
+
+declare interface ImageProps extends BaseElementProps, Omit<React.HTMLAttributes<HTMLImageElement>, "content"> {
+    alt: string;
+    image?: MediaContent;
+}
+
+export declare const IMembershipAuthenticationMethods: readonly ["linkedin", "google", "oauth", "microsoft", "otp", "whatsapp", "magiclink", "password"];
+
+export declare interface IMyBlockPages {
+    id: string;
+    title: string;
+    url: string;
+    kind: string;
+    status: string;
+}
+
+export declare interface IMyCategory {
+    name: string;
+    count: number;
+}
+
+export declare function Input({ className, type, ...props }: React_2.ComponentProps<"input">): JSX.Element;
+
+export declare const IntegrationFilters: default_2.FC<{
+    selectedFields: string[];
+    schema: ILemaCollection;
+    query: Record<string, any>;
+    setQuery: (val: Record<string, any>) => void;
+    enableSearch?: boolean;
+}>;
+
+export declare interface IPage {
+    id: string;
+    workspace_id: string;
+    site_id: string;
+    site_version?: "v1" | "v2";
+    title: string;
+    description: string;
+    key: string;
+    url: string;
+    live_url: string;
+    domain: string;
+    status: "published" | "draft";
+    meta: IPageMeta;
+    tags: IStudioTags[];
+    pagespeed_score: IPageSpeedData;
+    access: IPageAccess[];
+    settings: IPageSettings;
+    parent_id?: string;
+    language?: string;
+    is_generating?: boolean;
+    localized_pages?: ILocalizedPage[];
+    style_config?: ISiteStyleConfig | null;
+    countries?: string[];
+    theme: {
+        colors: {
+            brand: {
+                main: string;
+                foreground: string;
+                background: string;
+            };
+            brandSecondary: {
+                main: string;
+                foreground: string;
+                background: string;
+            };
+            text1: string;
+            text2: string;
+            text3: string;
+            [x: string]: any;
+        };
+    };
+    block_count: number;
+    variable_count: number;
+    source_count: number;
+    url_count: number;
+    created_at: string;
+    edit_count?: number;
+    updated_at: string;
+    thumbnail_url?: string;
+    thumbnail_url_mobile?: string;
+    source?: IStudioSource[];
+    kind: IPageKind;
+    sample_url: string;
+    insights: {
+        bounce_rate: IPageStatMetric;
+        page_views: IPageStatMetric;
+        scroll_depth: IPageStatMetric;
+    };
+    published_at: string | null;
+}
+
+export declare type IPageAccess = (IPageAccessGating | IPageAccessAuthentication) & {
+    enabled: boolean;
+};
+
+export declare type IPageAccessAuthentication = {
+    kind: "authentication";
+    options: IPageAccessAuthenticationOptions;
+};
+
+export declare type IPageAccessAuthenticationCodes = 
+/**
+* if `options.methods` is empty
+*/
+"authentication.NOT_CONFIGURED"
+/**
+* if `getNullableAccount` returns `null`, when `kind: authentication` is not optional
+*/
+| "authentication.NOT_LOGGED_IN" | "authentication.SUCCESS";
+
+export declare interface IPageAccessAuthenticationOptions {
+    methods: (typeof IMembershipAuthenticationMethods)[number][];
+    primary_method: (typeof IMembershipAuthenticationMethods)[number];
+}
+
+export declare interface IPageAccessCheck {
+    has_access: boolean;
+    code?: IPageAccessAuthenticationCodes | IPageAccessGatingCodes;
+    message: string;
+    options?: Pick<IPageAccessGatingOptions, "collection" | "field" | "content"> | IPageAccessAuthenticationOptions;
+}
+
+export declare type IPageAccessGating = {
+    kind: "gating";
+    options: IPageAccessGatingOptions;
+};
+
+export declare type IPageAccessGatingCodes = 
+/**
+* if `options.collection` is empty
+*/
+"gating.NOT_CONFIGURED"
+/**
+* if not `email` is given, and it could not fetched with authentication also
+*/
+| "gating.IDENTIFIER_NOT_FOUND"
+/**
+* if `options.collection` does not have entry with the given `email`
+*/
+| "gating.ENTRY_NOT_FOUND"
+/**
+* if `options.collection` has entry, but doesn't pass the `options.condition` criteria
+*/
+| "gating.ENTRY_CONDITION_NOT_FULFILLED" | "gating.SUCCESS";
+
+export declare interface IPageAccessGatingOptions {
+    collection: string;
+    field: string;
+    condition?: LevoQuery.Where;
+    default_value?: Record<string, any>;
+    hidden?: string[];
+    content?: {
+        entryNotFound?: string;
+        conditionNotFulfilled?: string;
+    };
+}
+
+export declare type IPageContext = Record<string, unknown>;
+
+export declare interface IPageDataContext {
+    page?: IPageContext;
+    blocks: Record<string, IBlockContext>;
+}
+
+export declare interface IPageExpanded extends IPage {
+    source: IStudioSource[];
+    kind: IPageKind;
+    blocks: (IBlockInstance & {
+        isPreview?: boolean;
+    })[];
+    access: IPageAccess[];
+}
+
+export declare interface IPageFromPath {
+    workspace: IWorkspace;
+    site: ISite;
+    query: Record<string, string>;
+    data: IPageExpanded | null;
+    access: IPageAccessCheck | null;
+}
+
+export declare type IPageKind = "blog.page" | "collection.page" | "community.page" | "event.page" | "static";
+
+export declare interface IPageMeta {
+    meta_title: string;
+    meta_description: string;
+    og_title: string;
+    og_description: string;
+    og_image: IMediaObject | null;
+    og_url: string;
+    keywords: string;
+    disable_indexing: boolean;
+    use_thumbnail_as_og_image?: boolean;
+}
+
+export declare interface IPageSettings {
+    structured_data_json?: string;
+    [key: string]: any;
+}
+
+export declare interface IPageSpeedData {
+    audit_id: string;
+    mobile: Scores;
+    desktop: Scores;
+    completed_at: string;
+}
+
+export declare interface IPageStatMetric {
+    current: number | null;
+    past: number | null;
+    change: number | null;
+}
+
+declare interface IPendingRequestStateProps {
+    communityName?: string;
+    className?: string;
+}
+
+export declare interface IPostActionsLoadingState {
+    engagements?: boolean;
+    comments?: boolean;
+    share?: boolean;
+}
+
+declare interface IPostsRestrictionOverlayProps {
+    isOpen: boolean;
+    communityName?: string;
+    className?: string;
+}
+
+declare type IPreviewDevice = "desktop" | "tablet" | "mobile";
+
+/**
+ * Type guard to check if a method is alternate (OAuth)
+ */
+export declare const isAlternateMethod: (method: AuthenticationMethod) => method is "google" | "linkedin" | "microsoft";
+
+/**
+ * Type guard to check if a config object has selectedVariants
+ */
+export declare const isConfigWithVariants: (val: unknown) => val is {
+    selectedVariants: Record<string, string>;
+};
+
+export declare interface ISelection {
+    blockId?: string;
+    elementKey?: string;
+    repeatableKey?: string;
+    repeatableParentKey?: string;
+}
+
+export declare interface ISendOTPParams {
+    email?: string;
+    phone?: string;
+    medium?: "email" | "whatsapp";
+}
+
+export declare type ISettingsField = {
+    type: "custom";
+    schema: {
+        field_interface: string;
+        settings?: Record<string, any>;
+    };
+} | {
+    type: "collection";
+    schema: IField;
+};
+
+export declare type ISettingsType = {
+    [key: string]: any;
+};
+
+export declare interface ISite {
+    object: string;
+    id: string;
+    workspace_id: string;
+    site_version: "v1" | "v2";
+    name: string;
+    slug: string;
+    timezone: string;
+    description: string;
+    logo: IMediaObject | null;
+    icon: IFaviconMediaObject | null;
+    industry: string | null;
+    domain: string | null;
+    theme: ITheme;
+    settings: {
+        head_code?: string;
+        studio_preview_url?: string;
+        staging_preview_url?: string;
+        contact_info?: IContactInfo;
+        social_media?: {
+            facebook?: string;
+            twitter?: string;
+            linkedin?: string;
+            instagram?: string;
+        };
+        [key: string]: any;
+    };
+    page_count: number;
+    domain_count: number;
+    robots: ISitemapsSettings;
+    is_default: boolean;
+    is_proxied: boolean;
+    host_domain: string | null;
+    proxy_domain: string | null;
+    style_config: ISiteStyleConfig | null;
+    created_at: string;
+    updated_at: string;
+}
+
+export declare type ISiteCompact = Pick<ISite, "object" | "id" | "name" | "slug" | "icon" | "logo" | "domain" | "domain_count" | "is_default" | "created_at" | "updated_at">;
+
+export declare interface ISitemap {
+    created_at: string;
+    filename: string;
+    id: string;
+    location: string;
+    name: string;
+    page_id: string | null;
+    path: string;
+    updated_at: string;
+    url_count: number;
+    workspace_id: string;
+}
+
+export declare interface ISitemapsSettings {
+    allow: string[];
+    disallow: string[];
+    sitemaps: string[];
+}
+
+export declare interface ISiteStyleConfig {
+    stylesheet_url: string | null;
+    critical_css: string | null;
+}
+
+export declare interface ISocketUser {
+    id: string;
+    first_name: string;
+    display_email: string;
+    profile_picture: IMediaObject;
+    last_name: string;
+    color: string;
+    block_id?: string | null;
+}
+
+/** Check if an error code indicates pending approval */
+export declare const isPendingApprovalError: (code?: string) => boolean;
+
+/**
+ * Type guard to check if a method is primary (passwordless)
+ */
+export declare const isPrimaryMethod: (method: AuthenticationMethod) => method is "otp" | "magiclink" | "whatsapp";
+
+/**
+ * Config passed to StripePaymentModal
+ */
+export declare interface IStripePaymentConfig {
+    clientSecret: string;
+}
+
+/**
+ * Payment metadata from API - for Stripe Embedded Checkout
+ */
+export declare interface IStripePaymentMeta {
+    /** Stripe publishable key (pk_xxx) */
+    key: string;
+    /** Checkout Session client_secret (for embedded mode) */
+    client_secret: string;
+    /** Amount in smallest denomination (cents/paise) */
+    amount: number;
+    /** ISO currency code */
+    currency: string;
+    /** Payment provider */
+    provider: "stripe";
+    /** Internal reference ID */
+    reference_id: string;
+}
+
+export declare type IStudioSource = {
+    id?: string;
+    module: (typeof BlockSourceModuleList)[number];
+    identifier: string;
+    field_key: string;
+    params?: Record<string, any>;
+    options?: {
+        sub_module?: "popular_posts" | "related_posts";
+        blog_id?: string;
+        context_key?: string;
+        filters?: {
+            enabled?: boolean;
+            selected_fields?: string[];
+        };
+    };
+    metadata?: Record<string, any>;
+    filters?: string[];
+    created_at?: string;
+    updated_at?: string;
+    block_instance_id?: string;
+    page_id?: string;
+};
+
+export declare interface IStudioTags {
+    id: string;
+    title: string;
+    slug: string;
+}
+
+export declare interface IStudioWidget {
+    label: string;
+    key: string;
+    field_interface: (typeof StudioWidgetList)[number];
+    kind?: (typeof KindList)[number];
+    fields?: IStudioWidget[];
+    options?: {
+        module_field?: {
+            module: (typeof BlockSourceModuleList)[number];
+            key?: string;
+        };
+    };
+    hint?: StudioHint;
+    custom_fields?: IStudioWidget[];
+}
+
+export declare type IStyles = {
+    [key in CSSStyleKeys]?: string;
+} & {
+    mobile?: {
+        [key in CSSStyleKeys]?: string;
+    };
+    tablet?: {
+        [key in CSSStyleKeys]?: string;
+    };
+};
+
+/**
+ * Validate if a string is a valid OKLCH color
+ * @returns {boolean} True if the string is a valid OKLCH color, false otherwise
+ */
+export declare const isValidOKLCH: (colorString: string) => boolean;
+
+export declare interface ITextareaProps extends IBaseInputProps {
+    label?: string;
+    isRequired?: boolean;
+    labelStyles?: string;
+    containerStyles?: string;
+    textAreaProps?: React_2.TextareaHTMLAttributes<HTMLTextAreaElement>;
+    textAreaStyles?: string;
+    onChange?: (e: React_2.ChangeEvent<HTMLTextAreaElement>) => void;
+    onBlur?: (e: React_2.FocusEvent<HTMLTextAreaElement>) => void;
+}
+
+/**
+ * Complete theme configuration for a workspace/page
+ *
+ * Combines legacy primitive theme properties (colors, fonts, sizes) with the new
+ * component-based theme system for maximum flexibility and backward compatibility
+ *
+ * CSS Generation:
+ * - Colors/fonts/sizes generate CSS custom properties (--color-brand, --font-heading, etc.)
+ * - Component default styles generate [data-levo_element_type] selectors
+ * - Component variants generate .levo-variant-{group}-{variant} class selectors
+ *
+ * @example
+ * // Complete theme structure
+ * {
+ *   colors: { brand: { main: "#007bff", foreground: "#fff" } },
+ *   fonts: { heading: "Inter", body: "Inter" },
+ *   sizes: { radius: "4px", spacing: "8px", fontSize: "14px" },
+ *   components: {
+ *     button: {
+ *       defaultStyles: { fontSize: "14px", borderRadius: "4px" },
+ *       variantGroups: {
+ *         variants: { variants: { primary: { backgroundColor: "#007bff" } } },
+ *         sizes: { variants: { large: { padding: "12px 20px" } } }
+ *       }
+ *     }
+ *   }
+ * }
+ */
+export declare interface ITheme {
+    colors: {
+        brand: {
+            main: OKLCHColor;
+            foreground: OKLCHColor;
+        };
+        brandSecondary: {
+            main: OKLCHColor;
+            foreground: OKLCHColor;
+        };
+        text1: OKLCHColor;
+        text2: OKLCHColor;
+        text3: OKLCHColor;
+        page: OKLCHColor;
+        border: OKLCHColor;
+        background1: OKLCHColor;
+        background2: OKLCHColor;
+        background3: OKLCHColor;
+        iconPrimary: OKLCHColor;
+        iconSecondary: OKLCHColor;
+        customColors?: Record<string, OKLCHColor>;
+    };
+    fonts: IThemeFonts;
+    sizes: {
+        radius: string;
+        spacing: string;
+        fontSize: string;
+    };
+    effects: {
+        shadow: string;
+    };
+    components: IThemeComponents;
+    [x: string]: unknown;
+}
+
+/**
+ * Container for all component themes in the system
+ *
+ * Pre-defines common component types while allowing custom components
+ * through the index signature
+ */
+export declare interface IThemeComponents {
+    heading?: IComponentTheme;
+    button?: IComponentTheme;
+    typography?: IComponentTheme;
+    container?: IComponentTheme;
+    icon?: IComponentTheme;
+    section?: IComponentTheme;
+}
+
+/**
+ * Font configuration for the theme system
+ * Defines which fonts to use for different text elements
+ */
+export declare type IThemeFonts = {
+    heading: string;
+    body: string;
+    customFonts?: Record<string, string>;
+};
+
+declare interface IUseDotButtonType {
+    selectedIndex: number;
+    scrollSnaps: number[];
+    onDotButtonClick: (index: number) => void;
+}
+
+export declare interface IUseLoginReturn {
+    sendOTP: (params: ISendOTPParams) => Promise<void>;
+    verifyOTP: (content: string, code: string) => Promise<ILevoMembership.Account | null>;
+    resendOTP: (params: ISendOTPParams) => Promise<void>;
+    sendMagicLink: (email: string) => Promise<void>;
+    refetchLoginStatus: (onRefetchSuccess?: (user: ILevoMembership.Account) => void) => void;
+    signOut: (onSignOutSuccess?: () => void, onSignOutError?: (error: LevoError) => void) => void;
+    isLoggedIn: boolean;
+    isAuthLoading: boolean;
+}
+
+export declare interface IUserHighlight {
+    id: string;
+    blockId: string;
+    color: string;
+    rect: HighlightRect | null;
+    element: HTMLElement | null;
+}
+
+/**
+ * Return type for useStripePayment hook
+ */
+export declare interface IUseStripePaymentReturn {
+    /** Stripe Promise for EmbeddedCheckoutProvider */
+    stripePromise: Promise<Stripe | null> | null;
+    /** Config for payment modal */
+    config: IStripePaymentConfig | null;
+    /** Whether modal is open */
+    isOpen: boolean;
+    /** Open the Stripe embedded checkout modal */
+    openStripeCheckout: (meta: IStripePaymentMeta) => Promise<void>;
+    /** Close the modal */
+    closeStripeCheckout: () => void;
+    /** Set completion callback */
+    setOnComplete: (callback: () => void) => void;
+    /** Completion callback */
+    onComplete: (() => void) | null;
+}
+
+/**
+ * Configuration for a single variant group within a component theme
+ *
+ * Variant groups organize related style variations (e.g., "Button Sizes", "Heading Levels")
+ * Each group contains multiple variants that users can select from
+ *
+ * @example
+ * // Button sizes variant group
+ * {
+ *   id: "sizes",
+ *   name: "Button Sizes",
+ *   variants: {
+ *     small: { fontSize: "12px", padding: "8px 12px" },
+ *     medium: { fontSize: "14px", padding: "10px 16px" },
+ *     large: { fontSize: "16px", padding: "12px 20px" }
+ *   }
+ * }
+ */
+export declare interface IVariantGroupConfig {
+    id: string;
+    name: string;
+    variants: Record<string, IElementStyle>;
+}
+
+/**
+ * Form for submitting a join request to an invite-only community
+ */
+export declare const JoinRequestForm: default_2.FC<IJoinRequestFormProps>;
+
+export declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): JSX.Element;
+
+export declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): JSX.Element;
+
+export declare const KindList: readonly ["element", "group"];
+
+/**
+ * Provides LazyMotion context with domAnimation features for reduced bundle size.
+ *
+ * Wrap your studio content with this provider to enable animations using the
+ * lighter `m` component instead of the full `motion` component (~18kb vs ~34kb).
+ */
+export declare const LazyMotionProvider: React.FC<ILazyMotionProviderProps>;
+
+export declare const LevoBlock: default_2.MemoExoticComponent<({ html_id, isBuilder, blocks, parsedBlockData, blockData, pageContext, blockContext, workspace_id, pageSource, }: LevoBlockProps) => JSX.Element>;
+
+declare interface LevoBlockProps {
+    html_id?: string;
+    isBuilder?: boolean;
+    blocks: Record<string, BlockComponent>;
+    parsedBlockData: IBlockInstance;
+    workspace_id: string;
+    blockData?: IBlockInstance;
+    pageContext?: IPageContext;
+    blockContext?: IPageDataContext["blocks"][number];
+    pageSource?: IPage["source"];
+}
+
+export declare const LevoPage: default_2.FC<ILevoPageProps>;
+
+export declare const Link: WithBlockPropsComponent<BaseLinkProps & RefAttributes<HTMLAnchorElement>>;
+
+export declare const Media: WithBlockPropsComponent<(Omit<BaseMediaProps & HTMLImageProps_2 & {
+isVideo?: false;
+}, "ref"> | Omit<BaseMediaProps & HTMLVideoProps & {
+isVideo: true;
+}, "ref">) & RefAttributes<HTMLElement>>;
+
+declare type MediaContent = {
+    location: string;
+    srcset?: {
+        path: string;
+    };
+} | IMedia;
+
+declare type MediaContent_2 = {
+    location: string;
+    srcset?: {
+        path: string;
+    };
+    type?: string;
+} | IMedia;
+
+export declare type MediaHint = {
+    orientation?: "landscape" | "portrait" | "square";
+    size?: "icon" | "small" | "medium" | "large" | "cover";
+    usecase?: "avatar" | "icon" | "hero" | "background" | "logo" | "other";
+};
+
+export declare const MESSAGE_TYPES: {
+    readonly PREVIEW_READY: "PREVIEW_READY";
+    readonly PREVIEW_HOVER: "PREVIEW_HOVER";
+    readonly PREVIEW_SELECT: "PREVIEW_SELECT";
+    readonly PREVIEW_MOUSE_LEAVE: "PREVIEW_MOUSE_LEAVE";
+    readonly PREVIEW_UNDO: "PREVIEW_UNDO";
+    readonly PREVIEW_REDO: "PREVIEW_REDO";
+    readonly STUDIO_SELECT: "STUDIO_SELECT";
+    readonly STUDIO_HOVER: "STUDIO_HOVER";
+    readonly STUDIO_AUTH_OVERRIDE: "STUDIO_AUTH_OVERRIDE";
+    readonly PREVIEW_TYPE: "PREVIEW_TYPE";
+    readonly LEVO_PAGE_DATA: "LEVO_PAGE_DATA";
+    readonly LEVO_BLOCK_DATA: "LEVO_BLOCK_DATA";
+    readonly FRAME_HEIGHT: "FRAME_HEIGHT";
+    readonly LEVO_USERS: "LEVO_USERS";
+};
+
+declare type MutableDeep<T> = T extends readonly (infer U)[] ? MutableDeep<U>[] : T extends object ? {
+    -readonly [K in keyof T]: MutableDeep<T[K]>;
+} : T;
+
+/**
+ * Normalizes a custom color name to a valid CSS variable suffix
+ * Replaces spaces with underscores, converts to lowercase
+ * Example: "Primary Accent" -> "primary_accent"
+ */
+export declare const normalizeColorName: (name: string) => string;
+
+/**
+ * Normalizes a custom font name to a valid CSS variable suffix
+ * Replaces spaces with underscores, converts to lowercase
+ * Example: "Code Font" -> "code_font"
+ */
+export declare const normalizeFontName: (name: string) => string;
+
+/**
+ * OKLCH color representation for theme storage
+ * Provides better color accuracy and perceptual uniformity than hex
+ */
+export declare interface OKLCHColor {
+    l: number;
+    c: number;
+    h: number;
+    alpha?: number;
+}
+
+/**
+ * Convert OKLCH CSS string to RGBA CSS string format
+ * Returns black color string for invalid input
+ */
+export declare const oklchStringToRGBA: (oklch: string) => string;
+
+/**
+ * Convert OKLCH object or string to hexadecimal color format
+ * Returns black color string for invalid input
+ */
+export declare const oklchToHex: (oklchColor: OKLCHColor | string | undefined) => string;
+
+/**
+ * Convert OKLCH object to RGBA string format for color pickers
+ * Returns black color string for invalid input
+ */
+export declare const oklchToRGBA: (oklchColor: OKLCHColor) => string;
+
+/**
+ * Convert OKLCH object to OKLCH CSS string format
+ */
+export declare const oklchToString: (oklchColor: OKLCHColor | string | undefined) => string;
+
+/**
+ * Parse element key to detect repeatable group context
+ *
+ * Searches backwards from the end to find the INNERMOST group pattern.
+ * Works for single-level groups (events.0.title) and nested groups (tabs.0.faqs.0.question).
+ *
+ * @param elementKey - Element key like "events.0.title" or "tabs.0.faqs.0.question"
+ * @returns Group context info or { isGroupItem: false }
+ *
+ * @example
+ * // Single-level group
+ * parseGroupContext("events.0.title")
+ * // Returns: { isGroupItem: true, groupKey: "events", itemIndex: 0, childKey: "title",
+ * //           groupItemKey: "events_levoGroupItem", sharedPath: "events_levoGroupItem.title" }
+ *
+ * @example
+ * // Nested group
+ * parseGroupContext("tabs.0.faqs.0.question")
+ * // Returns: { isGroupItem: true, groupKey: "faqs", itemIndex: 0, childKey: "question",
+ * //           groupItemKey: "faqs_levoGroupItem", sharedPath: "tabs_levoGroupItem.faqs_levoGroupItem.question" }
+ */
+export declare const parseGroupContext: (elementKey: string) => IGroupContext;
+
+/**
+ * Parse OKLCH string back to object format
+ * Returns default black color for invalid input
+ */
+export declare const parseOKLCHString: (oklchString: string) => OKLCHColor;
+
+declare type ParseResult = {
+    value: string;
+    prefix: string;
+};
+
+export declare const parseVariablesFromResolvedSource: ({ levoClient, block, resolvedSources, pageContext, siteData, cookies, draft, workspace_id, }: {
+    levoClient: ILevoClient;
+    block: IBlockInstance;
+    resolvedSources: IBlockInstance["source"];
+    workspace_id: string;
+    pageContext?: IPageContext;
+    siteData?: Record<string, any>;
+    cookies?: string;
+    draft?: boolean;
+}) => Promise<[IBlockInstance, Record<string, IResponseMultiple<Record<string, unknown>>>]>;
+
+/** Error code returned when account exists but is pending admin approval */
+export declare const PENDING_APPROVAL_ERROR_CODE = "membership.account.ACCOUNT_PENDING_APPROVAL";
+
+/**
+ * Display state shown when user has a pending join request
+ */
+export declare const PendingRequestState: default_2.FC<IPendingRequestStateProps>;
+
+export declare const PopoverContent: WithBlockPropsComponent<BasePopoverContentProps & {
+portalContainer?: Element | null;
+inPortal?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const PopoverRoot: React_2.FC<Popover.PopoverProps>;
+
+export declare const PopoverTrigger: WithBlockPropsComponent<BasePopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const PostActions: default_2.FC<{
+    post: IForumPost;
+    postDetailPageURLPattern?: string | null;
+    isRenderedSolo?: boolean;
+    actionsLoadingState?: IPostActionsLoadingState;
+    forumKey: string;
+}>;
+
+export declare const PostCategory: default_2.FC<{
+    post: IForumPost;
+}>;
+
+export declare const PostContent: default_2.FC<{
+    post: IForumPost;
+}>;
+
+export declare const PostGallery: default_2.FC<{
+    post: IForumPost;
+    isRenderedSolo?: boolean;
+}>;
+
+export declare const PostHeader: default_2.FC<{
+    post: IForumPost;
+    isRenderedSolo?: boolean;
+    forumKey?: string;
+    postListingPageURL?: string | null;
+    onEditClick?: () => void;
+    onPostUpdated?: (updatedPost: IForumPost) => void;
+}>;
+
+export declare const PostLink: default_2.FC<{
+    post: IForumPost;
+}>;
+
+export declare const PostLinkWrapper: default_2.FC<{
+    post: IForumPost;
+    postDetailPageURLPattern?: string | null;
+    children: default_2.ReactNode;
+}>;
+
+export declare const PostPoll: default_2.FC<{
+    post: IForumPost;
+}>;
+
+/**
+ * Dialog overlay shown when non-member tries to view posts in invite-only community
+ */
+export declare const PostsRestrictionOverlay: default_2.FC<IPostsRestrictionOverlayProps>;
+
+export declare const PostStatusBadge: default_2.FC<{
+    post: IForumPost;
+}>;
+
+export declare const PostTitle: default_2.FC<{
+    post: IForumPost;
+}>;
+
+/**
+ * Preset categories with metadata
+ */
+export declare const PRESET_CATEGORIES: {
+    readonly minimal: {
+        readonly label: "Minimal";
+        readonly description: "Clean, subtle effects that enhance without overwhelming";
+    };
+    readonly dynamic: {
+        readonly label: "Dynamic";
+        readonly description: "Animated effects that add movement and energy";
+    };
+    readonly interactive: {
+        readonly label: "Interactive";
+        readonly description: "Effects that respond to user interaction";
+    };
+    readonly custom: {
+        readonly label: "Custom";
+        readonly description: "User-created custom presets";
+    };
+};
+
+/**
+ * Map of preset IDs to their configurations for quick lookup
+ */
+export declare const PRESET_MAP: Record<string, BackgroundPreset>;
+
+/**
+ * Result type for preset operations
+ */
+export declare interface PresetOperationResult {
+    success: boolean;
+    config?: BackgroundEffectConfig;
+    error?: string;
+}
+
+export declare const PreviewHighlighter: React.FC<PreviewHighlighterProps>;
+
+declare interface PreviewHighlighterProps {
+    isPageGenerating?: boolean;
+    totalBlocksCount?: number;
+    blocksGenerationInfo?: IBlockGenerationInfo[];
+}
+
+/**
+ * Primary authentication methods (passwordless: OTP, Magic Link, WhatsApp)
+ */
+export declare const PRIMARY_AUTH_METHODS: IAuthenticationOption[];
+
+/**
+ * Primary method values for quick checking
+ */
+export declare const PRIMARY_METHOD_VALUES: ("linkedin" | "google" | "oauth" | "microsoft" | "otp" | "whatsapp" | "magiclink" | "password")[];
+
+/**
+ * Font Processing and Google Fonts Integration
+ *
+ * Extracts font families from theme configuration and generates Google Fonts
+ * URLs for loading. Handles deduplication and URL encoding.
+ *
+ * @param theme - Theme configuration containing font selections
+ * @returns Object with font list and Google Fonts URL
+ */
+export declare const processFonts: (theme: ITheme) => {
+    fonts: string[];
+    fontUrl: string;
+    fontTags: string;
+};
+
+/**
+ * Complete Theme Processing and CSS Generation
+ *
+ * This is the main entry point for theme processing. It orchestrates the entire
+ * CSS generation pipeline and produces the final CSS output for a page.
+ *
+ * Processing Steps:
+ * 1. Font processing and Google Fonts URL generation
+ * 2. CSS custom properties from primitive theme values
+ * 3. Component default styles and variant styles from theme configuration
+ * 4. Block-specific styles from individual block instances
+ * 5. HTML generation with font loading and scoped CSS
+ *
+ * CSS Scoping:
+ * All generated CSS is scoped to [data-levo-page-id='pageID'] to prevent
+ * style conflicts between different pages or instances.
+ *
+ * Output Structure:
+ * - Font preload and stylesheet links for performance
+ * - Three style blocks: theme variables, default styles, block styles
+ * - All CSS properly scoped and organized by purpose
+ *
+ * @param pageTheme - Complete theme configuration for the page
+ * @param blocks - Array of block instances with styling data
+ * @param pageID - Unique identifier for CSS scoping
+ * @returns Object with processed theme data and HTML for injection
+ */
+export declare const processTheme: ({ pageTheme, blocks, pageID, device, }: {
+    pageTheme: ITheme;
+    blocks?: IBlockInstance[];
+    pageID?: string;
+    device?: IPreviewDevice;
+}) => {
+    theme: ITheme;
+    fonts: string[];
+    fontUrl: string;
+    styles: {
+        theme: string;
+        default: string;
+        blocks: string;
+    };
+    html: string;
+};
+
+export declare const RegisterModal: ({ eventID, title, external, buttonText, }: {
+    eventID: string;
+    title?: string;
+    external?: string;
+    buttonText?: string;
+}) => JSX.Element;
+
+export declare const resolveStyles: ({ skeleton, blockFetchedContent, blockSources, currentPath, }: {
+    skeleton: any;
+    blockFetchedContent: Record<string, any>;
+    blockSources: IStudioSource[];
+    currentPath?: string;
+}) => any;
+
+export declare const resolveVariables: ({ skeleton, blockFetchedContent, blockSources, pageContext, siteData, currentPath, _resolvedKeys, _contextKeys, }: {
+    skeleton: any;
+    blockFetchedContent: Record<string, any>;
+    blockSources: IStudioSource[];
+    pageContext: Record<string, any>;
+    siteData?: Record<string, any>;
+    currentPath?: string;
+    _resolvedKeys?: Record<string, any>;
+    _contextKeys?: Record<string, any>;
+}) => any;
+
+/**
+ * Convert RGBA color to OKLCH object format for theme storage
+ * Returns default black color for invalid input
+ */
+export declare const rgbaToOKLCH: (rgba: {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}) => OKLCHColor;
+
+/**
+ * Convert RGBA to OKLCH CSS string format (for non-theme usage)
+ */
+export declare const rgbaToOKLCHString: (rgba: {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}) => string;
+
+/** Sample comment skeleton for background display */
+export declare const SampleCommentSkeleton: default_2.FC<{
+    opacity?: number;
+}>;
+
+/** Sample post skeleton for background display */
+export declare const SamplePostSkeleton: default_2.FC<{
+    opacity?: number;
+}>;
+
+/**
+ * Sanitizes a background effect configuration by removing invalid values
+ */
+export declare const sanitizeBackgroundEffectConfig: (config: BackgroundEffectConfig) => BackgroundEffectConfig;
+
+/**
+ * Sanitizes element key for use in CSS class names
+ * Replaces dots with dashes and removes invalid characters
+ */
+export declare const sanitizeElementKey: (elementKey: string) => string;
+
+declare interface Scores {
+    performance: number;
+    seo: number;
+    "best-practices": number;
+    accessibility: number;
+}
+
+/** Scroll-linked animation configuration with from/to states */
+export declare interface ScrollAnimationConfig {
+    from?: AnimationProperties;
+    to?: AnimationProperties;
+    offset?: ScrollAnimationOffset;
+}
+
+/** Scroll animation offset configuration */
+export declare interface ScrollAnimationOffset {
+    start: ScrollOffsetPosition;
+    end: ScrollOffsetPosition;
+}
+
+/**
+ * Valid scroll offset position strings for Motion's scroll() API
+ * Format: "element-position viewport-position"
+ * Examples: "start end" means animation starts when element's start meets viewport's end
+ */
+declare type ScrollOffsetPosition = "start start" | "start center" | "start end" | "center start" | "center center" | "center end" | "end start" | "end center" | "end end" | `start ${number}%` | `center ${number}%` | `end ${number}%` | `${number}% start` | `${number}% center` | `${number}% end` | `${number}% ${number}%`;
+
+export declare const SearchInput: default_2.FC<IInputProps>;
+
+export declare const Section: WithBlockPropsComponent<BaseSectionProps & default_2.RefAttributes<HTMLElement>>;
+
+export declare interface SelectableItem {
+    type: SelectableType;
+    rect: HighlightRect | null;
+    element: HTMLElement | null;
+    parentBlockId?: string;
+}
+
+export declare type SelectableType = "block" | "element" | "repeatable" | "repeatableParent";
+
+export declare interface SelectionState {
+    selected: Record<SelectableType, SelectableItem | null>;
+    hovered: Record<SelectableType, SelectableItem | null>;
+}
+
+export declare const SimpleTooltipWrapper: React_2.FC<{
+    children: React_2.ReactNode;
+    label?: string | React_2.ReactElement;
+    labelClassName?: string;
+    asChild?: boolean;
+    contentProps?: React_2.ComponentProps<typeof TooltipContent>;
+    side?: "top" | "bottom" | "left" | "right";
+}>;
+
+export declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): JSX.Element;
+
+export declare interface SourceFetchOptions {
+    levoClient: ILevoClient;
+    source: IStudioSource;
+    workspace_id: string;
+    slugs?: Record<string, string>;
+    params?: Record<string, unknown>;
+    cookies?: string;
+    draft?: boolean;
+}
+
+export declare interface SourceURL {
+    baseUrl: string;
+    path: string;
+    query?: Record<string, unknown>;
+}
+
+export declare const StatContainer: default_2.FC<default_2.ComponentProps<"div">>;
+
+export declare type StudioData = {
+    pageData?: {
+        pageData: IPageExpanded;
+        parsedPageData: IPageExpanded;
+        context?: IPageDataContext;
+        headCode?: string;
+    };
+    blockData?: {
+        blockData: IBlockInstance;
+        parsedBlockData: IBlockInstance;
+        context?: IPageDataContext;
+        theme?: ITheme;
+        blockContext?: Record<string, any>;
+        pageContext?: Record<string, any>;
+        pageSource?: IStudioSource[];
+    };
+    workspace?: IWorkspace;
+    site?: ISite;
+};
+
+export declare type StudioHint = {
+    prompt_description?: string;
+} & (MediaHint | ContentHint | GroupHint);
+
+export declare const StudioPreview: React.FC<{
+    blocks: Record<string, BlockComponent>;
+}>;
+
+export declare interface StudioState {
+    selected: ISelection;
+    hovered: ISelection;
+    actions: {
+        openBlockEditor: (params: ISelection) => void;
+        setHovered: (params: ISelection) => void;
+        setSelected: (params: ISelection) => void;
+    };
+}
+
+export declare const StudioWidgetList: readonly ["BoxWidget", "ButtonWidget", "LayoutWidget", "HeadingWidget", "IframeWidget", "ImageWidget", "IconWidget", "MediaWidget", "TypographyWidget", "BlogContentWidget", "CarouselWidget", "FormWidget", "ContainerWidget", "UserMenuWidget", "TabsListWidget", "TabsTriggerWidget", "TabsContentWidget", "CardWidget", "TitleWidget", "TextWidget", "NumberWidget", "URLWidget", "ImageUploadWidget", "MultiImageUploadWidget", "TextareaWidget", "RichTextWidget", "DropdownWidget", "SwitchWidget", "DateWidget", "ArrayWidget", "RecordWidget"];
+
+export declare const StudioWidgetMap: Record<"BoxWidget" | "ButtonWidget" | "LayoutWidget" | "HeadingWidget" | "IframeWidget" | "ImageWidget" | "IconWidget" | "MediaWidget" | "TypographyWidget" | "BlogContentWidget" | "CarouselWidget" | "FormWidget" | "ContainerWidget" | "UserMenuWidget" | "TabsListWidget" | "TabsTriggerWidget" | "TabsContentWidget" | "CardWidget" | "TitleWidget" | "TextWidget" | "NumberWidget" | "URLWidget" | "ImageUploadWidget" | "MultiImageUploadWidget" | "TextareaWidget" | "RichTextWidget" | "DropdownWidget" | "SwitchWidget" | "DateWidget" | "ArrayWidget" | "RecordWidget", "BoxWidget" | "ButtonWidget" | "LayoutWidget" | "HeadingWidget" | "IframeWidget" | "ImageWidget" | "IconWidget" | "MediaWidget" | "TypographyWidget" | "BlogContentWidget" | "CarouselWidget" | "FormWidget" | "ContainerWidget" | "UserMenuWidget" | "TabsListWidget" | "TabsTriggerWidget" | "TabsContentWidget" | "CardWidget" | "TitleWidget" | "TextWidget" | "NumberWidget" | "URLWidget" | "ImageUploadWidget" | "MultiImageUploadWidget" | "TextareaWidget" | "RichTextWidget" | "DropdownWidget" | "SwitchWidget" | "DateWidget" | "ArrayWidget" | "RecordWidget">;
+
+export declare const TabsContent: WithBlockPropsComponent<BaseTabsContentProps>;
+
+export declare const TabsList: WithBlockPropsComponent<BaseTabsListProps>;
+
+export declare const TabsRoot: React_2.ForwardRefExoticComponent<Tabs.TabsProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const TabsTrigger: WithBlockPropsComponent<BaseTabsTriggerProps>;
+
+export declare const Tooltip: React_2.FC<Tooltip_2.TooltipProps>;
+
+export declare const TooltipContent: React_2.ForwardRefExoticComponent<Omit<Tooltip_2.TooltipContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const TooltipPortal: React_2.FC<Tooltip_2.TooltipPortalProps>;
+
+export declare const TooltipProvider: React_2.FC<Tooltip_2.TooltipProviderProps>;
+
+export declare const TooltipTrigger: React_2.ForwardRefExoticComponent<Tooltip_2.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+/** Transition configuration for animations */
+export declare interface TransitionConfig {
+    type?: "spring" | "tween" | "keyframes";
+    duration?: number;
+    delay?: number;
+    /** Easing function for tween transitions */
+    ease?: TweenEase;
+    /** Bounce amount for spring transitions (0-1) */
+    bounce?: number;
+}
+
+/** Available easing functions for tween transitions */
+export declare type TweenEase = "linear" | "easeIn" | "easeOut" | "easeInOut" | "circIn" | "circOut" | "circInOut" | "backIn" | "backOut" | "backInOut" | "anticipate";
+
+declare type TypeAccordionComponentProps = React_2.ComponentPropsWithoutRef<typeof Accordion.Root>;
+
+declare type TypePopoverContentComponentProps = React_2.ComponentPropsWithoutRef<typeof Popover.Content>;
+
+declare type TypePopoverTriggerComponentProps = React_2.ComponentPropsWithoutRef<typeof Popover.Trigger>;
+
+declare type TypeTabsContentComponentProps = React_2.ComponentPropsWithoutRef<typeof Tabs.Content>;
+
+declare type TypeTabsListComponentProps = React_2.ComponentPropsWithoutRef<typeof Tabs.List>;
+
+declare type TypeTabsTriggerComponentProps = React_2.ComponentPropsWithoutRef<typeof Tabs.Trigger>;
+
+export declare const Typography: WithBlockPropsComponent<BaseTypographyProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const useAuth: () => IAuthProviderInterface;
+
+export declare const useBlockContext: () => BlockContextType;
+
+declare type UseCarouselParameters = Parameters<typeof default_3>;
+
+/**
+ * Hook to create memoized common props for components
+ * Excludes frequently changing props that don't affect animation
+ *
+ * @param props - The original props object
+ * @param elementKey - The element key
+ * @param configValue - The field configuration
+ * @param stylesValue - The styles value
+ * @param contentValue - The content value
+ * @param generatedClassName - The generated CSS class name
+ * @returns Memoized common props object
+ */
+export declare const useCommonProps: <P extends Record<string, unknown>>(props: P, elementKey: string, configValue: unknown, stylesValue: unknown, contentValue: unknown, generatedClassName: string) => ExtendedProps<P>;
+
+export declare const useContentEngine: (field_key: string) => {
+    query: Record<string, any>;
+    setQuery: (newQuery: Record<string, any>) => void;
+    loading: boolean;
+    data: any;
+    meta: IMeta | undefined;
+};
+
+export declare const useContextEngine: <T = Record<string, unknown>, M extends IMeta = IMeta>(field_key: string) => {
+    query: Record<string, any>;
+    setQuery: (newQuery: Record<string, any>) => void;
+    loading: boolean;
+    response: {
+        meta: M;
+        data: T[];
+    } | undefined;
+};
+
+export declare const useDotButton: (emblaApi: CarouselApi | undefined) => IUseDotButtonType;
+
+/**
+ * Hook to use forum context
+ */
+export declare const useForumContext: () => IForumContext;
+
+/**
+ * Hook to generate and memoize CSS class names for an element
+ * Prevents unnecessary re-renders when class names haven't changed
+ *
+ * @param elementKey - The element key identifier
+ * @param blockId - The block ID
+ * @param configValue - The field configuration
+ * @returns Memoized CSS class name string
+ */
+export declare const useGeneratedClassName: (elementKey: string, blockId: string, configValue: IFieldConfig | undefined) => string;
+
+/**
+ * Pure API operations hook for authentication
+ * All form state management moved to components with Formik
+ */
+export declare const useLogin: () => IUseLoginReturn;
+
+export declare const usePageContext: (module: IStudioSource["module"]) => any;
+
+export declare const UserMenu: WithBlockPropsComponent<BaseUserMenuProps>;
+
+/**
+ * Hook for managing Stripe Embedded Checkout modal
+ * Lazy loads Stripe SDK and manages modal state
+ */
+export declare const useStripePayment: () => IUseStripePaymentReturn;
+
+/** Viewport trigger configuration for entry animations */
+export declare interface ViewportConfig {
+    once?: boolean;
+    amount?: "some" | "all" | number;
+    margin?: string;
+}
+
+declare type WithBlockPropsComponent<P = {}> = (props: P & {
+    children?: BlockChildren;
+}) => ReactElement | null;
+
+export { }