@levo-so/studio 0.1.0

package/dist/blockSmith/ContentSchemaGenerator.d.ts

@@ -0,0 +1,4 @@
+import { IBlock } from '../interfaces';
+export declare const generateSchemaFromJSX: (jsx: string) => IBlock["content_schema"];
+export declare const convertKeysToPascalCase: (key: string) => string;
+//# sourceMappingURL=ContentSchemaGenerator.d.ts.map

package/dist/blockSmith/DefaultContentGenerator.d.ts

@@ -0,0 +1,2 @@
+export declare const generateDefaultContent: (contentSchema: any[]) => any;
+//# sourceMappingURL=DefaultContentGenerator.d.ts.map

package/dist/blockSmith/DefaultStylesGenerator.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DefaultStylesGenerator.d.ts.map

package/dist/blockSmith/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ContentSchemaGenerator';
+export * from './DefaultContentGenerator';
+//# sourceMappingURL=index.d.ts.map

package/dist/blockSmith/variablePropertMap.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=variablePropertMap.d.ts.map

package/dist/bridge/Highlighter.d.ts

@@ -0,0 +1,8 @@
+import { SelectionState } from './types';
+interface HighlighterProps {
+    selections: SelectionState;
+    isScrolling: boolean;
+}
+export declare const Highlighter: React.FC<HighlighterProps>;
+export {};
+//# sourceMappingURL=Highlighter.d.ts.map

package/dist/bridge/PreviewHighlighter.d.ts

@@ -0,0 +1,2 @@
+export declare const PreviewHighlighter: () => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PreviewHighlighter.d.ts.map

package/dist/bridge/StudioBlockPreview.d.ts

@@ -0,0 +1,7 @@
+import { BlockComponent } from '../interfaces';
+import { StudioData } from './StudioPreview';
+export declare const StudioBlockPreview: React.FC<{
+    blocks: Record<string, BlockComponent>;
+    studioData: StudioData["blockData"] | undefined;
+}>;
+//# sourceMappingURL=StudioBlockPreview.d.ts.map

package/dist/bridge/StudioPagePreview.d.ts

@@ -0,0 +1,16 @@
+import { IPageExpanded } from '../interfaces';
+import { ILevoPageProps } from '../core';
+import { IPageDataContext } from '../contentEngine';
+interface StudioPageData {
+    pageData: IPageExpanded;
+    parsedPageData: IPageExpanded;
+    context?: IPageDataContext;
+    headCode?: string;
+}
+export declare const StudioPagePreview: React.FC<{
+    blocks: ILevoPageProps["blocks"];
+    renderHighlights?: boolean;
+    studioData: StudioPageData | undefined;
+}>;
+export {};
+//# sourceMappingURL=StudioPagePreview.d.ts.map

package/dist/bridge/StudioPreview.d.ts

@@ -0,0 +1,20 @@
+import { IBlockInstance, IPageExpanded, ITheme, BlockComponent } from '../interfaces';
+import { IPageDataContext } from '../contentEngine';
+export type StudioData = {
+    pageData?: {
+        pageData: IPageExpanded;
+        parsedPageData: IPageExpanded;
+        context?: IPageDataContext;
+        headCode?: string;
+    };
+    blockData?: {
+        blockData: IBlockInstance;
+        parsedBlockData: IBlockInstance;
+        context?: IPageDataContext;
+        theme?: ITheme;
+    };
+};
+export declare const StudioPreview: React.FC<{
+    blocks: Record<string, BlockComponent>;
+}>;
+//# sourceMappingURL=StudioPreview.d.ts.map

package/dist/bridge/constants.d.ts

@@ -0,0 +1,7 @@
+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";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/bridge/index.d.ts

@@ -0,0 +1,5 @@
+export * from './PreviewHighlighter';
+export * from './types';
+export * from './constants';
+export * from './StudioPreview';
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/types.d.ts

@@ -0,0 +1,33 @@
+export type SelectableType = "block" | "element" | "repeatable" | "repeatableParent";
+export interface HighlightRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface SelectableItem {
+    type: SelectableType;
+    rect: HighlightRect | null;
+    element: HTMLElement | null;
+    parentBlockId?: string;
+}
+export interface SelectionState {
+    selected: Record<SelectableType, SelectableItem | null>;
+    hovered: Record<SelectableType, SelectableItem | null>;
+}
+export interface ISelection {
+    blockId?: string;
+    elementKey?: string;
+    repeatableKey?: string;
+    repeatableParentKey?: string;
+}
+export interface StudioState {
+    selected: ISelection;
+    hovered: ISelection;
+    actions: {
+        openBlockEditor: (params: ISelection) => void;
+        setHovered: (params: ISelection) => void;
+        setSelected: (params: ISelection) => void;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/bridge/utils.d.ts

@@ -0,0 +1,7 @@
+import { ISelection, HighlightRect, SelectionState } from './types';
+export declare function getElementCoordinates(element: HTMLElement): HighlightRect;
+export declare function getSelectionFromElement(element: HTMLElement): ISelection | null;
+export declare function findElementBySelection(selection: ISelection): HTMLElement | null;
+export declare function createSelectionState(element: HTMLElement, type: "selected" | "hovered"): SelectionState;
+export declare function updateSelectionRects(selections: SelectionState): SelectionState;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/ActionWrapper.d.ts

@@ -0,0 +1,8 @@
+import { IFieldConfig } from '../interfaces';
+import { ReactNode } from 'react';
+declare const ActionWrapper: React.FC<{
+    children: ReactNode;
+    config: IFieldConfig;
+}>;
+export default ActionWrapper;
+//# sourceMappingURL=ActionWrapper.d.ts.map

package/dist/components/BackgroundVideo.d.ts

@@ -0,0 +1,6 @@
+import { IFieldConfig } from '../interfaces';
+declare const BackgroundVideo: React.FC<{
+    backgroundVideo?: IFieldConfig["backgroundVideo"];
+}>;
+export default BackgroundVideo;
+//# sourceMappingURL=BackgroundVideo.d.ts.map

package/dist/components/backgroundPresets/Beams.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface BackgroundBeamsProps {
+    className?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    lineColor?: string;
+}
+export declare const BackgroundBeams: React.MemoExoticComponent<({ className, primaryColor, secondaryColor, lineColor, }: BackgroundBeamsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=Beams.d.ts.map

package/dist/components/backgroundPresets/Dots.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface BackgroundDotsProps {
+    className?: string;
+    dotColor?: string;
+    dotSize?: number;
+    spacing?: number;
+    isAnimated?: boolean;
+    speed?: number;
+}
+export declare const BackgroundDots: React.MemoExoticComponent<({ className, dotColor, dotSize, spacing, isAnimated, speed, }: BackgroundDotsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=Dots.d.ts.map

package/dist/components/backgroundPresets/Gradient.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface BackgroundGradientProps {
+    className?: string;
+    fromColor?: string;
+    toColor?: string;
+    direction?: string;
+}
+export declare const BackgroundGradient: React.MemoExoticComponent<({ className, fromColor, toColor, direction }: BackgroundGradientProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=Gradient.d.ts.map

package/dist/components/backgroundPresets/Grid.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface BackgroundGridProps {
+    className?: string;
+    lineColor?: string;
+    lineWidth?: number;
+    spacing?: number;
+    isInteractive?: boolean;
+    hoverColor?: string;
+    rows?: number;
+    cols?: number;
+}
+export declare const BackgroundGrid: React.MemoExoticComponent<({ className, lineColor, lineWidth, spacing, isInteractive, hoverColor, rows, cols, }: BackgroundGridProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=Grid.d.ts.map

package/dist/components/backgroundPresets/Waves.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface BackgroundWavesProps {
+    className?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    amplitude?: number;
+    frequency?: number;
+    speed?: number;
+}
+export declare const BackgroundWaves: React.MemoExoticComponent<({ className, primaryColor, secondaryColor, amplitude, frequency, speed, }: BackgroundWavesProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=Waves.d.ts.map

package/dist/components/backgroundPresets/exports.d.ts

@@ -0,0 +1,10 @@
+export { default as BackgroundEffects } from './index';
+export * from './presets';
+export * from './presetSystem';
+export * from './presetUtils';
+export { BackgroundBeams } from './Beams';
+export { BackgroundDots } from './Dots';
+export { BackgroundGrid } from './Grid';
+export { BackgroundGradient } from './Gradient';
+export { BackgroundWaves } from './Waves';
+//# sourceMappingURL=exports.d.ts.map

package/dist/components/backgroundPresets/index.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { BackgroundEffectConfig } from '../../interfaces';
+interface BackgroundEffectsProps {
+    config?: BackgroundEffectConfig;
+    presetId?: string;
+}
+declare const BackgroundEffects: React.FC<BackgroundEffectsProps>;
+export default BackgroundEffects;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/backgroundPresets/presetSystem.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Background Preset System
+ *
+ * This module provides a complete preset system for background effects,
+ * including built-in presets and application logic.
+ */
+export { BUILT_IN_PRESETS, PRESET_CATEGORIES, PRESET_MAP, getPresetsByCategory, getAvailableCategories, } from './presets';
+export { getEffectConfigFromPresetId, type PresetOperationResult, } from './presetUtils';
+export type { BackgroundPreset, BackgroundEffectConfig } from '../../interfaces';
+//# sourceMappingURL=presetSystem.d.ts.map

package/dist/components/backgroundPresets/presetUtils.d.ts

@@ -0,0 +1,19 @@
+import { BackgroundEffectConfig } from '../../interfaces';
+/**
+ * Result type for preset operations
+ */
+export interface PresetOperationResult {
+    success: boolean;
+    config?: BackgroundEffectConfig;
+    error?: string;
+}
+/**
+ * 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;
+/**
+ * Sanitizes a background effect configuration by removing invalid values
+ */
+export declare const sanitizeBackgroundEffectConfig: (config: BackgroundEffectConfig) => BackgroundEffectConfig;
+//# sourceMappingURL=presetUtils.d.ts.map

package/dist/components/backgroundPresets/presets.d.ts

@@ -0,0 +1,39 @@
+import { BackgroundPreset } from '../../interfaces';
+/**
+ * Built-in background effect presets organized by category
+ */
+export declare const BUILT_IN_PRESETS: BackgroundPreset[];
+/**
+ * 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: Map<string, BackgroundPreset>;
+/**
+ * Get presets by category
+ */
+export declare function getPresetsByCategory(category: BackgroundPreset["category"]): BackgroundPreset[];
+/**
+ * Get all available preset categories
+ */
+export declare function getAvailableCategories(): Array<BackgroundPreset["category"]>;
+//# sourceMappingURL=presets.d.ts.map

package/dist/components/withBlockProps copy.d.ts

@@ -0,0 +1,61 @@
+import { ComponentType, ForwardRefExoticComponent, ReactElement, RefAttributes, ReactNode } from 'react';
+import { IFieldConfig, IStyles } from '../interfaces';
+type RenderFunction = (item: unknown, index: number) => ReactNode;
+type BlockChildren = ReactNode | RenderFunction;
+/**
+ * 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
+ */
+export interface BaseElementProps {
+    elementKey: string;
+    styles?: IStyles;
+    config?: IFieldConfig;
+    content?: any;
+    generatedClassName?: string;
+}
+export interface WithBlockPropsComponent<P = {}> {
+    (props: P & {
+        children?: BlockChildren;
+    }): ReactElement | null;
+}
+/**
+ * withBlockProps - Higher-Order Component for Studio Elements
+ *
+ * This HOC enhances studio elements with block data and generates CSS classes
+ * for theme-based styling and targeting. It bridges the gap between block data
+ * and individual element instances.
+ *
+ * Key Features:
+ * 1. Injects element-specific config, styles, and content from block data
+ * 2. Generates CSS classes for element targeting and theme variants
+ * 3. Handles nested data access via dot-notation element keys
+ * 4. Provides consistent interface for all studio elements
+ * 5. Added support for Framer Motion animations driven by studio config
+ *
+ * CSS Class Generation:
+ * - Base class: `levo-{blockId}-{elementKey}` for unique element targeting
+ * - Variant classes: `levo-variant-{groupId}-{variantId}` for theme variants
+ *
+ * The generated classes enable:
+ * - Element-specific styling in CSS
+ * - Theme variant styling via class selectors
+ * - CSS cascade integration with theme system
+ *
+ * @example
+ * // Element with theme variants selected
+ * <Button elementKey="hero.button" />
+ *
+ * // If config.selectedVariants = { variants: "primary", sizes: "large" }
+ * // Renders with classes:
+ * // "levo-block123-hero-button levo-variant-variants-primary levo-variant-sizes-large"
+ *
+ * @param WrappedComponent - The component to enhance with block props
+ * @returns Enhanced component with automatic prop injection
+ */
+export declare const withBlockProps: <P extends BaseElementProps & {
+    children?: BlockChildren;
+}, R>(WrappedComponent: ComponentType<P> | ForwardRefExoticComponent<P & RefAttributes<R>>) => WithBlockPropsComponent<P>;
+export {};
+//# sourceMappingURL=withBlockProps%20copy.d.ts.map

package/dist/components/withBlockProps.d.ts

@@ -0,0 +1,61 @@
+import { ComponentType, ForwardRefExoticComponent, ReactElement, RefAttributes, ReactNode } from 'react';
+import { IFieldConfig, IStyles } from '../interfaces';
+type RenderFunction = (item: unknown, index: number) => ReactNode;
+type BlockChildren = ReactNode | RenderFunction;
+/**
+ * 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
+ */
+export interface BaseElementProps {
+    elementKey: string;
+    styles?: IStyles;
+    config?: IFieldConfig;
+    content?: any;
+    generatedClassName?: string;
+}
+export interface WithBlockPropsComponent<P = {}> {
+    (props: P & {
+        children?: BlockChildren;
+    }): ReactElement | null;
+}
+/**
+ * withBlockProps - Higher-Order Component for Studio Elements
+ *
+ * This HOC enhances studio elements with block data and generates CSS classes
+ * for theme-based styling and targeting. It bridges the gap between block data
+ * and individual element instances.
+ *
+ * Key Features:
+ * 1. Injects element-specific config, styles, and content from block data
+ * 2. Generates CSS classes for element targeting and theme variants
+ * 3. Handles nested data access via dot-notation element keys
+ * 4. Provides consistent interface for all studio elements
+ * 5. Added support for Framer Motion animations driven by studio config
+ *
+ * CSS Class Generation:
+ * - Base class: `levo-{blockId}-{elementKey}` for unique element targeting
+ * - Variant classes: `levo-variant-{groupId}-{variantId}` for theme variants
+ *
+ * The generated classes enable:
+ * - Element-specific styling in CSS
+ * - Theme variant styling via class selectors
+ * - CSS cascade integration with theme system
+ *
+ * @example
+ * // Element with theme variants selected
+ * <Button elementKey="hero.button" />
+ *
+ * // If config.selectedVariants = { variants: "primary", sizes: "large" }
+ * // Renders with classes:
+ * // "levo-block123-hero-button levo-variant-variants-primary levo-variant-sizes-large"
+ *
+ * @param WrappedComponent - The component to enhance with block props
+ * @returns Enhanced component with automatic prop injection
+ */
+export declare const withBlockProps: <P extends BaseElementProps & {
+    children?: BlockChildren;
+}, R>(WrappedComponent: ComponentType<P> | ForwardRefExoticComponent<P & RefAttributes<R>>) => WithBlockPropsComponent<P>;
+export {};
+//# sourceMappingURL=withBlockProps.d.ts.map

package/dist/contentEngine/cache.d.ts

@@ -0,0 +1,5 @@
+export declare const sourceCache: {
+    get: (key: string) => unknown | null;
+    set: (key: string, value: unknown) => void;
+};
+//# sourceMappingURL=cache.d.ts.map

package/dist/contentEngine/config.d.ts

@@ -0,0 +1,3 @@
+import { IBlockInstance } from '../interfaces';
+export declare const parseConfig: (block: IBlockInstance) => Promise<IBlockInstance>;
+//# sourceMappingURL=config.d.ts.map

package/dist/contentEngine/content.d.ts

@@ -0,0 +1,21 @@
+import { IResponseMultiple } from '@levo-so/core';
+import { IBlockInstance, IPageExpanded, IStudioSource } from '../interfaces';
+import { IPageContext, IPageDataContext } from './types';
+export declare const resolveVariables: ({ skeleton, blockFetchedContent, blockSource, pageContext, }: {
+    skeleton: any;
+    blockFetchedContent?: Record<string, any>;
+    blockSource?: IStudioSource;
+    pageContext?: Record<string, any>;
+}) => any;
+export declare const getPageSource: (pageData: IPageExpanded, slugs: Record<string, string>) => Promise<{
+    pageContext: IPageContext;
+    pageNotFound: boolean;
+}>;
+export declare const parseVariablesFromResolvedSource: (block: IBlockInstance, params: Record<string, unknown>, resolvedSource?: IBlockInstance["source"][0], pageContext?: IPageContext) => Promise<[IBlockInstance, IResponseMultiple["content"] | null]>;
+export declare const getInitialPageContent: (pageData: IPageExpanded, querySlugs: Record<string, string>, urlSlugs: string[]) => Promise<{
+    parsedPageData: IPageExpanded;
+    context?: IPageDataContext;
+    notFound: boolean;
+    headCode: string;
+}>;
+//# sourceMappingURL=content.d.ts.map

package/dist/contentEngine/getPage.d.ts

@@ -0,0 +1,8 @@
+import { IPageFromPath } from '../interfaces';
+export declare const getPageData: ({ workspace, url, draft, visitorParams, }: {
+    workspace: string;
+    url: string;
+    draft?: boolean;
+    visitorParams?: Record<string, unknown>;
+}) => Promise<IPageFromPath | null>;
+//# sourceMappingURL=getPage.d.ts.map

package/dist/contentEngine/head_code.d.ts

@@ -0,0 +1,3 @@
+import { IPageExpanded } from '../interfaces';
+export declare const generateHeadContent: (pageData: IPageExpanded, url: string) => string;
+//# sourceMappingURL=head_code.d.ts.map

package/dist/contentEngine/index.d.ts

@@ -0,0 +1,7 @@
+export * from './content';
+export * from './sourceFetcher';
+export * from './useContentEngine';
+export * from './types';
+export * from './getPage';
+export * from './themeUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/contentEngine/sourceFetcher.d.ts

@@ -0,0 +1,12 @@
+import { ILemaCollection, IResponseMultiple, IResponseSingle } from '@levo-so/core';
+import { SourceFetchOptions } from './types';
+export declare const fetchSource: ({ source, slugs, params, }: SourceFetchOptions) => Promise<IResponseMultiple | IResponseSingle | null>;
+export declare const fetchCollectionSchema: (source: {
+    workspace_id: string;
+    collection_id: string;
+}) => Promise<{
+    content: {
+        data: ILemaCollection | null;
+    };
+}>;
+//# sourceMappingURL=sourceFetcher.d.ts.map

package/dist/contentEngine/themeUtils.d.ts

@@ -0,0 +1,81 @@
+import { IBlockInstance, ITheme } from '../interfaces';
+/**
+ * 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
+ *
+ * @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;
+};
+/**
+ * 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, }: {
+    pageTheme: ITheme;
+    blocks?: IBlockInstance[];
+    pageID: string;
+}) => {
+    theme: ITheme;
+    fonts: string[];
+    fontUrl: string;
+    styles: {
+        theme: string;
+        default: string;
+        blocks: string;
+    };
+    html: string;
+};
+//# sourceMappingURL=themeUtils.d.ts.map

package/dist/contentEngine/types.d.ts

@@ -0,0 +1,25 @@
+import { IResponseMultiple } from '@levo-so/core';
+import { IStudioSource } from '../interfaces';
+export interface SourceURL {
+    baseUrl: string;
+    path: string;
+    query?: Record<string, unknown>;
+}
+export interface SourceFetchOptions {
+    source: IStudioSource;
+    slugs?: Record<string, string>;
+    params?: Record<string, unknown>;
+}
+export interface BlockTemplateOptions {
+    contentSkeleton: any;
+    blockFetchedContent: Record<string, any>;
+    blockSource?: IStudioSource;
+    pageContext?: Record<string, any>;
+}
+export type IPageContext = Record<string, unknown>;
+export type IBlockContext = Record<string, IResponseMultiple["content"]>;
+export interface IPageDataContext {
+    page?: IPageContext;
+    blocks: Record<string, IBlockContext>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/contentEngine/urlBuilder.d.ts

@@ -0,0 +1,3 @@
+import { IStudioSource } from '../interfaces';
+export declare const createSourceUrl: (source: IStudioSource, slug?: string, query?: Record<string, unknown>) => string;
+//# sourceMappingURL=urlBuilder.d.ts.map

package/dist/contentEngine/useContentEngine.d.ts

@@ -0,0 +1,9 @@
+export declare const useContentEngine: (field_key: string) => {
+    query: Record<string, any>;
+    setQuery: (newQuery: Record<string, any>) => void;
+    loading: boolean;
+    data: any;
+    meta: import('@levo-so/core').IMeta | undefined;
+};
+export default useContentEngine;
+//# sourceMappingURL=useContentEngine.d.ts.map