@foxpixel/react 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, ComponentType } from 'react';
+import React, { ReactNode, ComponentType } from 'react';
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
 
 /**
@@ -188,6 +188,8 @@ interface AuthContextValue {
         phone?: string;
     }) => Promise<void>;
     refetch: () => Promise<void>;
+    /** Stub: returns true when user is logged in and permission is site:content:update. */
+    hasPermission: (permission: string) => boolean;
 }
 interface AuthProviderProps {
     children: ReactNode;
@@ -261,6 +263,54 @@ interface WithAuthOptions {
 }
 declare function withAuth<P extends object>(Component: ComponentType<P>, options?: WithAuthOptions): (props: P) => string | number | true | Iterable<ReactNode> | react_jsx_runtime.JSX.Element | null;
 
+interface EditableProps {
+    contentKey: string;
+    defaultValue: string;
+    as?: keyof JSX.IntrinsicElements;
+    multiline?: boolean;
+    className?: string;
+}
+declare function Editable({ contentKey, defaultValue, as, multiline, className, }: EditableProps): React.ReactElement<{
+    className: string;
+    'aria-busy': boolean;
+    'aria-label': string;
+}, string | React.JSXElementConstructor<any>> | React.DOMElement<{
+    className: string;
+    'data-content-key': string;
+    'data-editable': string | undefined;
+    onClick: ((e: React.MouseEvent) => void) | undefined;
+    title: string | undefined;
+}, Element>;
+/**
+ * Renders rich HTML content from the CMS. Content is sanitized before rendering.
+ */
+declare function EditableHTML({ contentKey, defaultValue, as, className, }: Omit<EditableProps, 'multiline'>): React.ReactElement<{
+    className: string;
+    'aria-busy': boolean;
+}, string | React.JSXElementConstructor<any>> | React.DOMElement<{
+    className: string;
+    'data-content-key': string;
+    'data-editable': string | undefined;
+    onClick: ((e: React.MouseEvent) => void) | undefined;
+    title: string | undefined;
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+}, Element>;
+interface EditableImageProps {
+    contentKey: string;
+    defaultValue: string;
+    alt: string;
+    className?: string;
+    width?: number;
+    height?: number;
+    priority?: boolean;
+}
+/**
+ * Renders an image from a CMS-managed URL. Uses native img (no Next.js Image in SDK).
+ */
+declare function EditableImage({ contentKey, defaultValue, alt, className, width, height, priority, }: EditableImageProps): react_jsx_runtime.JSX.Element;
+
 /**
  * Hook to fetch and manage services (Projects module)
  */
@@ -405,4 +455,693 @@ interface UseContactCaptureReturn {
  */
 declare function useContactCapture(): UseContactCaptureReturn;
 
-export { type ApiError$1 as ApiError, AuthProvider, type CreateLeadRequest, type EndUser, type EndUserLoginRequest, type FoxPixelConfig, FoxPixelHttpClient, FoxPixelProvider, GuestOnlyRoute, type Lead, ProtectedRoute, type Service, type ServiceCatalogResponse, useAuth, useContactCapture, useFoxPixelContext, useLeadCapture, useServices, withAuth };
+/**
+ * Hook for managing editable site content (CMS Visual)
+ *
+ * Allows non-developers to edit text content directly on the site.
+ */
+
+interface SiteContent {
+    id: string;
+    contentKey: string;
+    value: string | null;
+    contentType: string;
+    defaultValue: string | null;
+    description: string | null;
+    section: string | null;
+    sortOrder: number;
+    isActive: boolean;
+    updatedAt: string | null;
+}
+interface UseSiteContentOptions {
+    /**
+     * Default value to use if content is not found
+     */
+    defaultValue?: string;
+    /**
+     * Whether to fetch on mount (default: true)
+     */
+    fetchOnMount?: boolean;
+}
+interface UseSiteContentReturn {
+    /**
+     * The content object (null if not found or loading)
+     */
+    data: SiteContent | null;
+    /**
+     * The content value (or defaultValue if not found)
+     */
+    value: string;
+    /**
+     * Whether content is being loaded
+     */
+    isLoading: boolean;
+    /**
+     * Error if request failed
+     */
+    error: ApiError$1 | null;
+    /**
+     * Whether the current user can edit this content
+     */
+    canEdit: boolean;
+    /**
+     * Update the content value
+     */
+    update: (newValue: string) => Promise<void>;
+    /**
+     * Refetch the content
+     */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for managing a single site content key.
+ *
+ * @example
+ * ```tsx
+ * function HeroSection() {
+ *   const { value, canEdit, update } = useSiteContent('hero.title', {
+ *     defaultValue: 'Welcome to our site'
+ *   });
+ *
+ *   const [isEditing, setIsEditing] = useState(false);
+ *   const [editValue, setEditValue] = useState(value);
+ *
+ *   const handleSave = async () => {
+ *     await update(editValue);
+ *     setIsEditing(false);
+ *   };
+ *
+ *   if (canEdit && isEditing) {
+ *     return (
+ *       <input
+ *         value={editValue}
+ *         onChange={(e) => setEditValue(e.target.value)}
+ *         onBlur={handleSave}
+ *       />
+ *     );
+ *   }
+ *
+ *   return (
+ *     <h1 onClick={() => canEdit && setIsEditing(true)}>
+ *       {value}
+ *     </h1>
+ *   );
+ * }
+ * ```
+ */
+declare function useSiteContent(contentKey: string, options?: UseSiteContentOptions): UseSiteContentReturn;
+interface UseSiteContentsOptions {
+    /**
+     * Default values map
+     */
+    defaults?: Record<string, string>;
+}
+interface UseSiteContentsReturn {
+    /**
+     * Map of content key to content object
+     */
+    data: Record<string, SiteContent>;
+    /**
+     * Get value by key (with default fallback)
+     */
+    getValue: (key: string, defaultValue?: string) => string;
+    /**
+     * Whether contents are being loaded
+     */
+    isLoading: boolean;
+    /**
+     * Error if request failed
+     */
+    error: ApiError$1 | null;
+    /**
+     * Refetch all contents
+     */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching multiple site content keys at once.
+ * More efficient than calling useSiteContent multiple times.
+ *
+ * @example
+ * ```tsx
+ * function Footer() {
+ *   const { getValue, isLoading } = useSiteContents(
+ *     ['footer.copyright', 'footer.address', 'footer.phone'],
+ *     { defaults: { 'footer.copyright': '© 2024' } }
+ *   );
+ *
+ *   if (isLoading) return null;
+ *
+ *   return (
+ *     <footer>
+ *       <p>{getValue('footer.copyright')}</p>
+ *       <p>{getValue('footer.address')}</p>
+ *       <p>{getValue('footer.phone')}</p>
+ *     </footer>
+ *   );
+ * }
+ * ```
+ */
+declare function useSiteContents(contentKeys: string[], options?: UseSiteContentsOptions): UseSiteContentsReturn;
+interface UseSiteContentSectionReturn {
+    /**
+     * List of contents in the section
+     */
+    contents: SiteContent[];
+    /**
+     * Whether contents are being loaded
+     */
+    isLoading: boolean;
+    /**
+     * Error if request failed
+     */
+    error: ApiError$1 | null;
+    /**
+     * Refetch section contents
+     */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching all content in a section.
+ *
+ * @example
+ * ```tsx
+ * function HeroSection() {
+ *   const { contents, isLoading } = useSiteContentSection('hero');
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {contents.map(content => (
+ *         <div key={content.contentKey}>{content.value}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSiteContentSection(section: string): UseSiteContentSectionReturn;
+
+/**
+ * Edit-mode hooks for CMS Visual (iframe communication with Tenant Admin).
+ * When edit-mode=true is in the URL, the site enters edit mode and communicates
+ * with the parent iframe via postMessage.
+ */
+/** Query key used for site content; must match useSiteContentQuery. */
+declare const SITE_CONTENT_QUERY_KEY: "siteContent";
+/**
+ * Returns true when the page is in edit mode (URL has edit-mode=true).
+ * Used to show edit affordances and enable postMessage communication.
+ */
+declare function useEditMode(): boolean;
+/**
+ * Sets up edit-mode messaging: notifies parent when ready and listens for
+ * FOXPIXEL_CONTENT_UPDATED to invalidate the corresponding site content query.
+ * App must be wrapped in QueryClientProvider when using edit mode.
+ */
+declare function useEditModeMessaging(): boolean;
+/**
+ * Returns a callback to send an edit request to the parent iframe.
+ * Only has effect when in edit mode.
+ */
+declare function useSendEditRequest(): (contentKey: string, currentValue: string, contentType?: string, section?: string, description?: string) => void;
+
+/**
+ * React Query-based hook for site content used by Editable components.
+ * Uses queryKey ['siteContent', key] so that useEditModeMessaging can invalidate
+ * on FOXPIXEL_CONTENT_UPDATED. Requires QueryClientProvider.
+ */
+interface UseSiteContentQueryOptions {
+    defaultValue: string;
+}
+interface UseSiteContentQueryReturn {
+    value: string;
+    isLoading: boolean;
+    contentType: string;
+}
+/**
+ * Fetches a single site content by key using React Query. Used by Editable, EditableHTML, EditableImage.
+ * Invalidation is triggered by useEditModeMessaging when the parent sends FOXPIXEL_CONTENT_UPDATED.
+ */
+declare function useSiteContentQuery(contentKey: string, options: UseSiteContentQueryOptions): UseSiteContentQueryReturn;
+
+/**
+ * Blog module types for FoxPixel SDK
+ * Aligned with backend BlogPostResponse, BlogCategoryResponse, BlogTagResponse
+ */
+interface BlogAuthor {
+    id: string;
+    name: string;
+    email?: string;
+}
+interface BlogCategory {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    color?: string;
+    sortOrder?: number;
+}
+interface BlogTag {
+    id: string;
+    name: string;
+    slug: string;
+}
+type BlogPostStatus = 'DRAFT' | 'SCHEDULED' | 'PUBLISHED' | 'ARCHIVED';
+interface BlogPost {
+    id: string;
+    title: string;
+    slug: string;
+    excerpt: string | null;
+    content: string;
+    coverImageUrl: string | null;
+    metaTitle: string | null;
+    metaDescription: string | null;
+    canonicalUrl: string | null;
+    ogTitle: string | null;
+    ogDescription: string | null;
+    ogImageUrl: string | null;
+    status: BlogPostStatus;
+    publishedAt: string | null;
+    scheduledAt: string | null;
+    readingTimeMinutes: number | null;
+    isFeatured: boolean;
+    allowComments: boolean;
+    authorId: string | null;
+    author?: BlogAuthor | null;
+    version: number;
+    isAiGenerated: boolean;
+    categories: BlogCategory[];
+    tags: BlogTag[];
+    createdAt: string;
+    updatedAt: string;
+}
+/** Spring Data Page response shape */
+interface BlogPostPage {
+    content: BlogPost[];
+    totalElements: number;
+    totalPages: number;
+    size: number;
+    number: number;
+    first: boolean;
+    last: boolean;
+    numberOfElements: number;
+    empty: boolean;
+}
+/** Blog comment (approved, for display) */
+interface BlogComment {
+    id: string;
+    postId: string;
+    postTitle?: string | null;
+    postSlug?: string | null;
+    parentId?: string | null;
+    authorName?: string | null;
+    content: string;
+    status: string;
+    createdAt: string;
+    replies?: BlogComment[];
+}
+/** Payload to create a comment (guest) */
+interface CreateBlogCommentPayload {
+    guestName?: string;
+    guestEmail?: string;
+    content: string;
+    parentId?: string;
+}
+type NewsletterFrequency = 'instant' | 'daily' | 'weekly' | 'monthly';
+type NewsletterStatus = 'ACTIVE' | 'UNSUBSCRIBED' | 'BOUNCED';
+interface NewsletterSubscriber {
+    id: string;
+    email: string;
+    name?: string | null;
+    frequency: NewsletterFrequency;
+    categories?: string[] | null;
+    status: NewsletterStatus;
+    source?: string | null;
+    confirmedAt?: string | null;
+    unsubscribedAt?: string | null;
+    createdAt: string;
+}
+interface SubscribeNewsletterPayload {
+    email: string;
+    name?: string;
+    frequency?: NewsletterFrequency;
+    categories?: string[];
+    source?: string;
+}
+interface NewsletterSubscriberPage {
+    content: NewsletterSubscriber[];
+    totalElements: number;
+    totalPages: number;
+    size: number;
+    number: number;
+    first: boolean;
+    last: boolean;
+    numberOfElements: number;
+    empty: boolean;
+}
+interface NewsletterStats {
+    activeSubscribers: number;
+}
+interface BlogSettings {
+    businessContext?: string | null;
+    defaultLanguage?: string | null;
+    automationEnabled?: boolean | null;
+    autoPublishAsDraft?: boolean | null;
+    siteUrl?: string | null;
+    organizationName?: string | null;
+    blogName?: string | null;
+}
+interface BlogAnalyticsSummary {
+    totalViews: number;
+    totalUniqueVisitors: number;
+    totalPosts: number;
+    publishedPosts: number;
+    draftPosts: number;
+    scheduledPosts: number;
+    topPosts?: Array<{
+        postId: string;
+        postTitle: string;
+        postSlug: string;
+        views: number;
+    }>;
+}
+interface PostAnalyticsRow {
+    postId: string;
+    postTitle: string;
+    postSlug: string;
+    date: string;
+    views: number;
+    uniqueVisitors: number;
+}
+
+/**
+ * Hooks for Blog module (public API - SDK / headless)
+ */
+
+interface UseBlogPostsOptions {
+    page?: number;
+    limit?: number;
+}
+interface UseBlogPostsReturn {
+    data: BlogPostPage | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch published blog posts (paginated)
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useBlogPosts({ page: 0, limit: 10 });
+ * data?.content.map(post => <PostCard key={post.id} post={post} />)
+ * ```
+ */
+declare function useBlogPosts(options?: UseBlogPostsOptions): UseBlogPostsReturn;
+interface UseBlogPostReturn {
+    data: BlogPost | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch a single published blog post by slug
+ *
+ * @example
+ * ```tsx
+ * const { data: post, isLoading } = useBlogPost('my-post-slug');
+ * ```
+ */
+declare function useBlogPost(slug: string | undefined | null): UseBlogPostReturn;
+interface UseBlogCategoriesReturn {
+    data: BlogCategory[] | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch blog categories (for filters / navigation)
+ */
+declare function useBlogCategories(): UseBlogCategoriesReturn;
+interface UseBlogTagsReturn {
+    data: BlogTag[] | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch blog tags (for filters / display)
+ */
+declare function useBlogTags(): UseBlogTagsReturn;
+interface UseBlogCommentsReturn {
+    data: BlogComment[] | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch approved comments for a published blog post (public API)
+ *
+ * @example
+ * ```tsx
+ * const { data: comments, refetch } = useBlogComments(post?.slug);
+ * ```
+ */
+declare function useBlogComments(slug: string | undefined | null): UseBlogCommentsReturn;
+interface UseBlogCommentSubmitReturn {
+    submit: (payload: CreateBlogCommentPayload) => Promise<BlogComment | null>;
+    isSubmitting: boolean;
+    error: ApiError$1 | null;
+    resetError: () => void;
+}
+/**
+ * Submit a comment on a published blog post (public API). Call refetch on comments after success.
+ *
+ * @example
+ * ```tsx
+ * const { submit, isSubmitting, error } = useBlogCommentSubmit(post?.slug);
+ * await submit({ guestName: 'João', guestEmail: 'j@x.com', content: 'Texto' });
+ * refetch(); // from useBlogComments
+ * ```
+ */
+declare function useBlogCommentSubmit(slug: string | undefined | null): UseBlogCommentSubmitReturn;
+interface UseBlogFeaturedPostsReturn {
+    data: BlogPostPage | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Fetch featured blog posts
+ */
+declare function useBlogFeaturedPosts(limit?: number): UseBlogFeaturedPostsReturn;
+interface UseNewsletterSubscribeReturn {
+    subscribe: (payload: SubscribeNewsletterPayload) => Promise<NewsletterSubscriber | null>;
+    isSubmitting: boolean;
+    error: ApiError$1 | null;
+    success: boolean;
+    reset: () => void;
+}
+/**
+ * Subscribe to newsletter (public API)
+ *
+ * @example
+ * ```tsx
+ * const { subscribe, isSubmitting, success, error } = useNewsletterSubscribe();
+ * await subscribe({ email: 'user@example.com', name: 'John' });
+ * ```
+ */
+declare function useNewsletterSubscribe(): UseNewsletterSubscribeReturn;
+interface UseNewsletterUnsubscribeReturn {
+    unsubscribe: (email: string) => Promise<boolean>;
+    /** Cancelar inscrição pelo token (link no email de confirmação). */
+    unsubscribeByToken: (token: string) => Promise<boolean>;
+    isSubmitting: boolean;
+    error: ApiError$1 | null;
+    success: boolean;
+}
+/**
+ * Unsubscribe from newsletter (public API)
+ */
+declare function useNewsletterUnsubscribe(): UseNewsletterUnsubscribeReturn;
+
+/**
+ * Admin hooks for Blog module (tenant-admin dashboard)
+ * These hooks use the authenticated admin API endpoints
+ */
+
+interface CreateBlogPostPayload {
+    title: string;
+    slug?: string;
+    excerpt?: string;
+    content: string;
+    coverImageUrl?: string;
+    metaTitle?: string;
+    metaDescription?: string;
+    canonicalUrl?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImageUrl?: string;
+    status?: 'DRAFT' | 'SCHEDULED' | 'PUBLISHED';
+    scheduledAt?: string;
+    isFeatured?: boolean;
+    allowComments?: boolean;
+    categoryIds?: string[];
+    tagIds?: string[];
+    isAiGenerated?: boolean;
+    aiGenerationMetadata?: Record<string, unknown>;
+    businessContextSnapshot?: string;
+}
+interface UpdateBlogPostPayload extends Partial<CreateBlogPostPayload> {
+    changeReason?: string;
+}
+interface UseAdminBlogPostsOptions {
+    page?: number;
+    size?: number;
+}
+interface UseAdminBlogPostsReturn {
+    data: BlogPostPage | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+declare function useAdminBlogPosts(options?: UseAdminBlogPostsOptions): UseAdminBlogPostsReturn;
+interface UseAdminBlogPostReturn {
+    data: BlogPost | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+declare function useAdminBlogPost(id: string | undefined | null): UseAdminBlogPostReturn;
+interface UseAdminBlogPostMutationsReturn {
+    create: (payload: CreateBlogPostPayload) => Promise<BlogPost | null>;
+    update: (id: string, payload: UpdateBlogPostPayload) => Promise<BlogPost | null>;
+    remove: (id: string) => Promise<boolean>;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+}
+declare function useAdminBlogPostMutations(): UseAdminBlogPostMutationsReturn;
+interface CreateCategoryPayload {
+    name: string;
+    slug?: string;
+    description?: string;
+    color?: string;
+    parentId?: string;
+    sortOrder?: number;
+}
+interface UseAdminBlogCategoriesReturn {
+    data: BlogCategory[] | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+    create: (payload: CreateCategoryPayload) => Promise<BlogCategory | null>;
+    update: (id: string, payload: Partial<CreateCategoryPayload>) => Promise<BlogCategory | null>;
+    remove: (id: string) => Promise<boolean>;
+}
+declare function useAdminBlogCategories(): UseAdminBlogCategoriesReturn;
+interface CreateTagPayload {
+    name: string;
+    slug?: string;
+}
+interface UseAdminBlogTagsReturn {
+    data: BlogTag[] | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+    create: (payload: CreateTagPayload) => Promise<BlogTag | null>;
+    update: (id: string, payload: Partial<CreateTagPayload>) => Promise<BlogTag | null>;
+    remove: (id: string) => Promise<boolean>;
+}
+declare function useAdminBlogTags(): UseAdminBlogTagsReturn;
+interface UseAdminBlogCommentsOptions {
+    status?: string;
+    postId?: string;
+    page?: number;
+    size?: number;
+}
+interface BlogCommentAdmin extends BlogComment {
+    postTitle?: string;
+    postSlug?: string;
+    authorEmail?: string;
+}
+interface BlogCommentPage {
+    content: BlogCommentAdmin[];
+    totalElements: number;
+    totalPages: number;
+    size: number;
+    number: number;
+    first: boolean;
+    last: boolean;
+    empty: boolean;
+}
+interface UseAdminBlogCommentsReturn {
+    data: BlogCommentPage | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+    updateStatus: (id: string, status: 'APPROVED' | 'REJECTED' | 'SPAM') => Promise<boolean>;
+    remove: (id: string) => Promise<boolean>;
+}
+declare function useAdminBlogComments(options?: UseAdminBlogCommentsOptions): UseAdminBlogCommentsReturn;
+interface UseAdminNewsletterSubscribersOptions {
+    status?: string;
+    page?: number;
+    size?: number;
+}
+interface UseAdminNewsletterSubscribersReturn {
+    data: NewsletterSubscriberPage | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+    remove: (id: string) => Promise<boolean>;
+}
+declare function useAdminNewsletterSubscribers(options?: UseAdminNewsletterSubscribersOptions): UseAdminNewsletterSubscribersReturn;
+interface UseAdminNewsletterStatsReturn {
+    data: NewsletterStats | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+declare function useAdminNewsletterStats(): UseAdminNewsletterStatsReturn;
+interface UseAdminBlogSettingsReturn {
+    data: BlogSettings | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+    update: (settings: Partial<BlogSettings>) => Promise<BlogSettings | null>;
+}
+declare function useAdminBlogSettings(): UseAdminBlogSettingsReturn;
+interface UseAdminBlogAnalyticsReturn {
+    data: BlogAnalyticsSummary | null;
+    isLoading: boolean;
+    error: ApiError$1 | null;
+    refetch: () => Promise<void>;
+}
+declare function useAdminBlogAnalytics(): UseAdminBlogAnalyticsReturn;
+
+/**
+ * Blog utilities - Schema.org JSON-LD for SEO
+ */
+
+interface BlogPostSchemaLdOptions {
+    /** Full URL of the site (e.g. https://example.com) */
+    siteUrl: string;
+    /** Organization name for publisher */
+    publisherName?: string;
+    /** Logo URL for publisher */
+    publisherLogoUrl?: string;
+}
+/**
+ * Build Schema.org BlogPosting JSON-LD for a blog post
+ *
+ * @example
+ * ```tsx
+ * const schemaLd = getBlogPostSchemaLd(post, { siteUrl: 'https://example.com', publisherName: 'My Site' });
+ * <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(schemaLd) }} />
+ * ```
+ */
+declare function getBlogPostSchemaLd(post: BlogPost, options: BlogPostSchemaLdOptions): Record<string, unknown>;
+
+export { type ApiError$1 as ApiError, AuthProvider, type BlogAnalyticsSummary, type BlogAuthor, type BlogCategory, type BlogComment, type BlogCommentAdmin, type BlogCommentPage, type BlogPost, type BlogPostPage, type BlogPostSchemaLdOptions, type BlogPostStatus, type BlogSettings, type BlogTag, type CreateBlogCommentPayload, type CreateBlogPostPayload, type CreateCategoryPayload, type CreateLeadRequest, type CreateTagPayload, Editable, EditableHTML, EditableImage, type EditableImageProps, type EditableProps, type EndUser, type EndUserLoginRequest, type FoxPixelConfig, FoxPixelHttpClient, FoxPixelProvider, GuestOnlyRoute, type Lead, type NewsletterFrequency, type NewsletterStats, type NewsletterStatus, type NewsletterSubscriber, type NewsletterSubscriberPage, type PostAnalyticsRow, ProtectedRoute, SITE_CONTENT_QUERY_KEY, type Service, type ServiceCatalogResponse, type SiteContent, type SubscribeNewsletterPayload, type UpdateBlogPostPayload, type UseAdminBlogAnalyticsReturn, type UseAdminBlogCategoriesReturn, type UseAdminBlogCommentsOptions, type UseAdminBlogCommentsReturn, type UseAdminBlogPostMutationsReturn, type UseAdminBlogPostReturn, type UseAdminBlogPostsOptions, type UseAdminBlogPostsReturn, type UseAdminBlogSettingsReturn, type UseAdminBlogTagsReturn, type UseAdminNewsletterStatsReturn, type UseAdminNewsletterSubscribersOptions, type UseAdminNewsletterSubscribersReturn, type UseBlogCategoriesReturn, type UseBlogCommentSubmitReturn, type UseBlogCommentsReturn, type UseBlogFeaturedPostsReturn, type UseBlogPostReturn, type UseBlogPostsOptions, type UseBlogPostsReturn, type UseBlogTagsReturn, type UseNewsletterSubscribeReturn, type UseNewsletterUnsubscribeReturn, type UseSiteContentOptions, type UseSiteContentQueryOptions, type UseSiteContentQueryReturn, type UseSiteContentReturn, type UseSiteContentSectionReturn, type UseSiteContentsOptions, type UseSiteContentsReturn, getBlogPostSchemaLd, useAdminBlogAnalytics, useAdminBlogCategories, useAdminBlogComments, useAdminBlogPost, useAdminBlogPostMutations, useAdminBlogPosts, useAdminBlogSettings, useAdminBlogTags, useAdminNewsletterStats, useAdminNewsletterSubscribers, useAuth, useBlogCategories, useBlogCommentSubmit, useBlogComments, useBlogFeaturedPosts, useBlogPost, useBlogPosts, useBlogTags, useContactCapture, useEditMode, useEditModeMessaging, useFoxPixelContext, useLeadCapture, useNewsletterSubscribe, useNewsletterUnsubscribe, useSendEditRequest, useServices, useSiteContent, useSiteContentQuery, useSiteContentSection, useSiteContents, withAuth };