@gaddario98/react-core 2.0.2 → 2.0.3

package/dist/pages/index.d.ts

@@ -0,0 +1,1827 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _gaddario98_react_form from '@gaddario98/react-form';
+import { FieldValues, FormManagerConfig, Submit, SetValueFunction, FormManager, SubmitKeysArg, FormElements } from '@gaddario98/react-form';
+import { QueriesArray, MultipleQueryResponse, AllMutation, QueryDefinition, MutationConfig, QueryProps, QueryAtIndex, ExtractQuery } from '@gaddario98/react-queries';
+import { DeepKeys, DeepValue } from '@tanstack/react-form';
+import { ComponentProps } from 'react';
+import * as _gaddario98_react_state from '@gaddario98/react-state';
+import { AuthState } from '@gaddario98/react-auth';
+import * as jotai_family from 'jotai-family';
+import * as jotai from 'jotai';
+
+/**
+ * Metadata Configuration Types
+ * Custom metadata system replacing react-helmet-async
+ * Platform-agnostic: works on web, React Native, and SSR
+ */
+
+/**
+ * Context passed to dynamic metadata evaluator functions
+ * Provides access to form values, queries, and page state
+ */
+type MetadataEvaluatorContext<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> = FunctionProps<F, Q>;
+interface MetaTag {
+    /** For <meta name="..." content="..." /> */
+    name?: string;
+    /** For <meta property="og:..." content="..." /> */
+    property?: string;
+    /** For <meta http-equiv="..." content="..." /> */
+    httpEquiv?: string;
+    /** Meta tag content */
+    content: string;
+    /** Unique identifier for updating existing tags */
+    id?: string;
+}
+/**
+ * Open Graph Image Configuration
+ */
+interface OpenGraphImage {
+    /** Absolute URL to the image */
+    url: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** Image width in pixels */
+    width?: number;
+    /** Image height in pixels */
+    height?: number;
+    /** MIME type (e.g., "image/jpeg", "image/png") */
+    type?: string;
+}
+/**
+ * Open Graph Article Configuration (when type='article')
+ */
+interface OpenGraphArticle {
+    /** ISO 8601 date string */
+    publishedTime?: string;
+    /** ISO 8601 date string */
+    modifiedTime?: string;
+    /** ISO 8601 date string */
+    expirationTime?: string;
+    /** Author name or URL */
+    author?: string | Array<string>;
+    /** Article section/category */
+    section?: string;
+    /** Article tags */
+    tags?: Array<string>;
+}
+/**
+ * Open Graph Configuration (Facebook, LinkedIn, etc.)
+ */
+interface OpenGraphConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    type?: 'website' | 'article' | 'product' | 'profile';
+    title?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    description?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Single image URL or full image config */
+    image?: string | OpenGraphImage | ((context: MetadataEvaluatorContext<F, Q>) => string | OpenGraphImage);
+    /** Multiple images for the page */
+    images?: Array<OpenGraphImage> | ((context: MetadataEvaluatorContext<F, Q>) => Array<OpenGraphImage>);
+    /** Canonical URL */
+    url?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    siteName?: string;
+    /** Locale (e.g., "en_US", "it_IT") */
+    locale?: string;
+    /** Article-specific metadata (when type='article') */
+    article?: OpenGraphArticle;
+}
+/**
+ * Twitter Card Configuration
+ */
+interface TwitterCardConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Card type */
+    card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    /** @username of the website */
+    site?: string;
+    /** @username of the content creator */
+    creator?: string;
+    /** Title (falls back to og:title then page title) */
+    title?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Description (falls back to og:description then page description) */
+    description?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Image URL (falls back to og:image) */
+    image?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Alt text for the image */
+    imageAlt?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+}
+/**
+ * Alternate languages/URLs configuration for i18n SEO
+ */
+interface AlternatesConfig {
+    /** Canonical URL for this page */
+    canonical?: string;
+    /** Map of locale → URL for hreflang tags (e.g., { "en": "/en/page", "it": "/it/page" }) */
+    languages?: Record<string, string>;
+    /** Media-specific alternates (e.g., mobile version) */
+    media?: Record<string, string>;
+    /** RSS/Atom feed alternates */
+    types?: Record<string, Array<{
+        url: string;
+        title?: string;
+    }>>;
+}
+/**
+ * Icon configuration
+ */
+interface IconConfig {
+    /** URL to the icon */
+    url: string;
+    /** Icon type (e.g., "image/png", "image/svg+xml") */
+    type?: string;
+    /** Icon sizes (e.g., "32x32", "192x192") */
+    sizes?: string;
+    /** Color for SVG mask icons */
+    color?: string;
+}
+/**
+ * Icons & PWA configuration
+ */
+interface IconsConfig {
+    /** Standard favicon(s) - link[rel="icon"] */
+    icon?: string | IconConfig | Array<IconConfig>;
+    /** Apple touch icon(s) - link[rel="apple-touch-icon"] */
+    apple?: string | IconConfig | Array<IconConfig>;
+    /** Shortcut icon (legacy) */
+    shortcut?: string;
+}
+/**
+ * Structured Data Configuration (schema.org JSON-LD)
+ */
+interface StructuredDataConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    type: 'Article' | 'Product' | 'WebPage' | 'FAQPage' | 'Organization' | 'Person' | 'WebSite' | 'BreadcrumbList';
+    schema: Record<string, unknown> | ((context: MetadataEvaluatorContext<F, Q>) => Record<string, unknown>);
+}
+/**
+ * AI Crawler Hints (for AI search engines and LLMs)
+ */
+interface AIHintsConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Content classification (e.g., "documentation", "tutorial", "reference") */
+    contentClassification?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Hints for AI models (e.g., ["code-heavy", "technical"]) */
+    modelHints?: Array<string> | ((context: MetadataEvaluatorContext<F, Q>) => Array<string>);
+    /** Additional context for AI understanding */
+    contextualInfo?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Exclude this page from AI crawler indexing */
+    excludeFromIndexing?: boolean;
+}
+/**
+ * Robots Configuration (indexing directives)
+ */
+interface RobotsConfig {
+    /** Prevent indexing */
+    noindex?: boolean;
+    /** Don't follow links */
+    nofollow?: boolean;
+    /** Don't cache page */
+    noarchive?: boolean;
+    /** Don't show snippets in search results */
+    nosnippet?: boolean;
+    /** Image preview size in search results */
+    maxImagePreview?: 'none' | 'standard' | 'large';
+    /** Max snippet length in search results */
+    maxSnippet?: number;
+}
+/**
+ * Resolved Metadata - all dynamic functions have been evaluated.
+ * This is the output of resolveMetadata() and is what gets applied to the DOM
+ * or passed to framework helpers (toNextMetadata, etc.).
+ */
+interface ResolvedMetadata {
+    title?: string;
+    description?: string;
+    canonical?: string;
+    lang?: string;
+    keywords?: Array<string>;
+    author?: string;
+    viewport?: string;
+    themeColor?: string;
+    openGraph?: {
+        type?: 'website' | 'article' | 'product' | 'profile';
+        title?: string;
+        description?: string;
+        image?: string | OpenGraphImage;
+        images?: Array<OpenGraphImage>;
+        url?: string;
+        siteName?: string;
+        locale?: string;
+        article?: OpenGraphArticle;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        imageAlt?: string;
+    };
+    alternates?: AlternatesConfig;
+    icons?: IconsConfig;
+    /** Web app manifest URL */
+    manifest?: string;
+    structuredData?: {
+        type: string;
+        schema: Record<string, unknown>;
+    };
+    aiHints?: {
+        contentClassification?: string;
+        modelHints?: Array<string>;
+        contextualInfo?: string;
+        excludeFromIndexing?: boolean;
+    };
+    robots?: RobotsConfig;
+    disableIndexing?: boolean;
+    customMeta?: Array<MetaTag>;
+}
+/**
+ * Complete Metadata Configuration (Generic over F and Q for dynamic metadata)
+ * This is the "input" type — values can be strings or evaluator functions.
+ * Use resolveMetadata() to convert this to ResolvedMetadata.
+ */
+interface MetadataConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Page title - sets document.title on web */
+    title?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Page description meta tag */
+    description?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** Canonical URL for the page */
+    canonical?: string | ((context: MetadataEvaluatorContext<F, Q>) => string);
+    /** HTML lang attribute (e.g., "en", "it") */
+    lang?: string;
+    /**
+     * @deprecated Use `lang` instead. Will be removed in a future version.
+     */
+    documentLang?: string;
+    /** Keywords for SEO */
+    keywords?: Array<string> | ((context: MetadataEvaluatorContext<F, Q>) => Array<string>);
+    openGraph?: OpenGraphConfig<F, Q>;
+    twitter?: TwitterCardConfig<F, Q>;
+    alternates?: AlternatesConfig;
+    icons?: IconsConfig;
+    /** Web app manifest URL */
+    manifest?: string;
+    structuredData?: StructuredDataConfig<F, Q>;
+    aiHints?: AIHintsConfig<F, Q>;
+    robots?: RobotsConfig;
+    customMeta?: Array<MetaTag> | ((context: MetadataEvaluatorContext<F, Q>) => Array<MetaTag>);
+    disableIndexing?: boolean;
+    /** Author meta tag */
+    author?: string;
+    /** Viewport meta tag (defaults to "width=device-width, initial-scale=1") */
+    viewport?: string;
+    /** Theme color for browser UI */
+    themeColor?: string;
+}
+/**
+ * Request-scoped metadata store.
+ * In SSR each request gets its own store to avoid cross-request leaks.
+ * On the client, a single global store is used.
+ */
+interface MetadataStore {
+    /** Get current resolved metadata */
+    getMetadata: () => ResolvedMetadata;
+    /** Set (merge) resolved metadata into the store */
+    setMetadata: (meta: ResolvedMetadata) => void;
+    /** Reset store to empty */
+    reset: () => void;
+}
+interface MetadataProvider {
+    /** Apply metadata configuration to the page */
+    setMetadata: (config: MetadataConfig) => void;
+    /** Get current metadata configuration */
+    getMetadata: () => MetadataConfig;
+    /** Reset all metadata to defaults */
+    resetMetadata: () => void;
+}
+/**
+ * Configuration for lazy loading and code splitting behavior
+ * Enables deferred component loading to reduce initial bundle size
+ */
+interface LazyLoadingConfig<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Enable lazy loading (default: true) */
+    enabled?: boolean;
+    /** Preload on hover for interactive elements (default: false) */
+    preloadOnHover?: boolean;
+    /** Preload on focus for keyboard navigation (default: false) */
+    preloadOnFocus?: boolean;
+    /** Preload after render with delay (in ms, default: undefined - no delay) */
+    preloadAfterRender?: number;
+    /** Fallback component to show while loading (default: null) */
+    suspenseFallback?: React.ReactNode;
+    /** Custom error boundary component for lazy-loaded modules */
+    errorBoundary?: React.ComponentType<{
+        error: Error;
+        retry: () => void;
+    }>;
+    /** Maximum time to wait before showing error state (in ms, default: 30000) */
+    timeout?: number;
+    /** Log performance metrics for lazy loading (development only) */
+    logMetrics?: boolean;
+    /** IntersectionObserver threshold (0-1, default: 0.1) - alias for intersectionThreshold */
+    threshold?: number | Array<number>;
+    /** IntersectionObserver threshold (0-1, default: 0.1) */
+    intersectionThreshold?: number | Array<number>;
+    /** IntersectionObserver root margin (default: "100px") - alias for intersectionRootMargin */
+    rootMargin?: string;
+    /** IntersectionObserver root margin (default: "100px") */
+    intersectionRootMargin?: string;
+    /** Trigger type for lazy loading: viewport (IntersectionObserver), interaction (manual), or conditional (based on function) */
+    trigger?: 'viewport' | 'interaction' | 'conditional';
+    /** Conditional function to determine if content should load (for trigger: "conditional") */
+    condition?: (context: MetadataEvaluatorContext<F, Q>) => boolean;
+    /** Placeholder component to show before lazy content loads */
+    placeholder?: React.ReactNode;
+}
+/**
+ * Entry for the llms.txt file
+ */
+interface LlmsTxtEntry {
+    /** URL of the page */
+    url: string;
+    /** Short title / label for this page */
+    title: string;
+    /** Brief description for the LLM */
+    description?: string;
+}
+/**
+ * Configuration for llms.txt generation
+ */
+interface LlmsTxtConfig {
+    /** Site title / name shown at the top of llms.txt */
+    siteName: string;
+    /** Brief description of the site */
+    siteDescription?: string;
+    /** Curated list of pages to expose in llms.txt */
+    entries: Array<LlmsTxtEntry>;
+}
+
+/**
+ * Metadata Store, DOM Application, and Server Collection
+ *
+ * Architecture:
+ * - `createMetadataStore()` → request-scoped store (SSR-safe)
+ * - `applyMetadataToDom(resolved)` → client-side DOM manipulation
+ * - `collectMetadataToHtml(resolved)` → server-side HTML string collection
+ * - `setMetadata / getMetadata / resetMetadata` → backward-compatible global API
+ *
+ * @module config/metadata
+ */
+
+/**
+ * Create a new request-scoped metadata store.
+ * In SSR, each incoming request should create its own store
+ * to avoid cross-request data leaks.
+ * On the client, a single global store is used (see below).
+ */
+declare function createMetadataStore(): MetadataStore;
+/**
+ * Apply resolved metadata to the document `<head>`.
+ * Client-only: this function does nothing if `document` is not available.
+ * Covers: title, description, canonical, lang, keywords, author, viewport,
+ *         themeColor, Open Graph (advanced), Twitter Card, alternates/hreflang,
+ *         icons, manifest, structured data JSON-LD, AI hints, robots, customMeta.
+ */
+declare function applyMetadataToDom(resolved: ResolvedMetadata): void;
+/**
+ * Collect resolved metadata as an HTML string for SSR injection into `<head>`.
+ * Pure function — no DOM, no side effects.
+ */
+declare function collectMetadataToHtml(resolved: ResolvedMetadata): string;
+/**
+ * Apply metadata configuration to the page.
+ * Merges with existing metadata in the global store.
+ * On web: also applies changes to the DOM.
+ *
+ * @deprecated Prefer using `MetadataStoreProvider` + `resolveMetadata` + `applyMetadataToDom`
+ *             for SSR-safe, request-scoped metadata management.
+ */
+declare const setMetadata: (config: MetadataConfig) => void;
+/**
+ * Get current metadata from the global store.
+ * @deprecated Prefer using `MetadataStoreProvider` context in SSR.
+ */
+declare const getMetadata: () => MetadataConfig;
+/**
+ * Reset all metadata in the global store.
+ * @deprecated Prefer using `MetadataStoreProvider` context in SSR.
+ */
+declare const resetMetadata: () => void;
+
+/**
+ * resolveMetadata — Pure function that evaluates dynamic MetadataConfig into ResolvedMetadata.
+ *
+ * All evaluator functions (title, description, og fields, twitter fields, etc.)
+ * are called with the provided context. The result is a plain object with no functions.
+ *
+ * This function has NO side effects: no DOM, no global state.
+ *
+ * @module config/resolveMetadata
+ */
+
+/**
+ * Resolve a MetadataConfig (which may contain evaluator functions)
+ * into a plain ResolvedMetadata object.
+ *
+ * @param meta - The metadata configuration (static or with dynamic functions)
+ * @param ctx  - The context providing get/set accessors for queries, form, state
+ * @returns Fully resolved metadata with all functions evaluated
+ */
+declare function resolveMetadata<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray>(meta: MetadataConfig<F, Q>, ctx: MetadataEvaluatorContext<F, Q>): ResolvedMetadata;
+
+interface MetadataStoreProviderProps {
+    /** Optional pre-created store. If not provided, a new one is created. */
+    store?: MetadataStore;
+    children: React.ReactNode;
+}
+/**
+ * Provides a request-scoped MetadataStore via React Context.
+ *
+ * @example SSR (one per request)
+ * ```tsx
+ * import { createMetadataStore, MetadataStoreProvider } from '@/core/pages';
+ *
+ * function handleRequest(req, res) {
+ *   const store = createMetadataStore();
+ *   const html = renderToString(
+ *     <MetadataStoreProvider store={store}>
+ *       <App />
+ *     </MetadataStoreProvider>
+ *   );
+ *   const headHtml = collectMetadataToHtml(store.getMetadata());
+ *   // inject headHtml into <head>
+ * }
+ * ```
+ */
+declare function MetadataStoreProvider({ store, children, }: MetadataStoreProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the nearest request-scoped MetadataStore.
+ * Returns `null` if no provider is found (falls back to global store in consumers).
+ */
+declare function useMetadataStore(): MetadataStore | null;
+
+/**
+ * Optional dev-only metadata logging.
+ *
+ * Tracks what metadata was resolved and applied, useful for debugging
+ * metadata issues during development.
+ *
+ * Logging is a no-op in production builds.
+ *
+ * @module config/metadataLogger
+ */
+
+interface MetadataLogEntry {
+    pageId: string;
+    action: 'resolve' | 'apply-dom' | 'apply-store' | 'translate';
+    metadata: ResolvedMetadata;
+    timestamp: number;
+}
+/**
+ * Enable or disable metadata logging.
+ * Only effective in development mode.
+ */
+declare function setMetadataLogging(enabled: boolean): void;
+/**
+ * Log a metadata action (resolve, apply, translate).
+ * No-op in production or when logging is disabled.
+ */
+declare function logMetadata(pageId: string, action: MetadataLogEntry['action'], metadata: ResolvedMetadata): void;
+/**
+ * Get all logged metadata entries (dev only).
+ * Useful for inspecting metadata in browser devtools.
+ */
+declare function getMetadataLog(): Array<MetadataLogEntry>;
+/**
+ * Clear the metadata log.
+ */
+declare function clearMetadataLog(): void;
+
+interface DefaultContainerProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    children?: Array<React.JSX.Element>;
+    allContents: Array<ContentItem<F, Q, V> | FormManagerConfig<F> | Submit<F>>;
+    handleRefresh?: () => void;
+    viewSettings?: ViewSettings;
+    pageId?: string;
+}
+type PageAuthState = {
+    id: string;
+    accountVerified?: boolean;
+    isLogged?: boolean;
+    token?: string;
+    phoneNumber?: string;
+    email?: string;
+};
+interface PageTranslationOptions {
+    [key: string]: string | number | boolean | undefined;
+    ns?: string;
+}
+interface PageConfigProps {
+    HeaderContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps<F, Q, V>, 'viewSettings'> & ViewSettings['header']) => React.ReactNode;
+    FooterContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps<F, Q, V>, 'viewSettings'> & ViewSettings['footer']) => React.ReactNode;
+    BodyContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: DefaultContainerProps<F, Q, V>) => React.ReactNode;
+    authPageImage: string;
+    authPageProps: PageProps;
+    isLogged: (val: AuthState | null) => boolean;
+    ItemsContainer: (props: {
+        children: React.ReactNode;
+    }) => React.ReactNode;
+    LoaderComponent?: (props: {
+        loading?: boolean;
+        message?: string;
+        ns?: string;
+    }) => React.ReactNode;
+    PageContainer: (props: {
+        children: React.ReactNode;
+        id: string;
+    }) => React.ReactNode;
+    meta?: {
+        title?: string;
+        description?: string;
+    };
+    defaultMetadata: MetadataConfig;
+    setMetadata: (config: MetadataConfig) => void;
+    getMetadata: () => MetadataConfig;
+    resetMetadata: () => void;
+    lazyLoading: LazyLoadingConfig;
+    authValues?: PageAuthState | null;
+    locale?: string;
+    translateText?: (key: string, options?: PageTranslationOptions) => string;
+}
+declare function getPageConfig(): PageConfigProps;
+declare const pageConfigAtom: _gaddario98_react_state.PrimitiveAtom<PageConfigProps>;
+declare const usePageConfigValue: () => PageConfigProps;
+declare const usePageConfigState: () => [PageConfigProps, (value: PageConfigProps) => void];
+declare const usePageConfigReset: () => () => void;
+
+type StringKey<T> = Extract<keyof T, string>;
+type VariableTopKey<V> = StringKey<V>;
+type VariableValue<V, K extends VariableTopKey<V>> = V[K];
+type QueryTopKey<Q extends QueriesArray> = StringKey<MultipleQueryResponse<Q>>;
+type QuerySubKey<Q extends QueriesArray, K extends QueryTopKey<Q>> = StringKey<MultipleQueryResponse<Q>[K]>;
+type QueryCompositeKey<Q extends QueriesArray> = {
+    [K in QueryTopKey<Q>]: K | `${K}.${QuerySubKey<Q, K>}`;
+}[QueryTopKey<Q>];
+type QueryValue<Q extends QueriesArray, K extends QueryCompositeKey<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends QueryTopKey<Q> ? Sub extends QuerySubKey<Q, Top> ? MultipleQueryResponse<Q>[Top][Sub] : never : never : K extends QueryTopKey<Q> ? MultipleQueryResponse<Q>[K] : never;
+type MutationTopKey<Q extends QueriesArray> = StringKey<AllMutation<Q>>;
+type MutationSubKey<Q extends QueriesArray, K extends MutationTopKey<Q>> = StringKey<AllMutation<Q>[K]>;
+type MutationCompositeKey<Q extends QueriesArray> = {
+    [K in MutationTopKey<Q>]: K | `${K}.${MutationSubKey<Q, K>}`;
+}[MutationTopKey<Q>];
+type MutationValue<Q extends QueriesArray, K extends MutationCompositeKey<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends MutationTopKey<Q> ? Sub extends MutationSubKey<Q, Top> ? AllMutation<Q>[Top][Sub] : never : never : K extends MutationTopKey<Q> ? AllMutation<Q>[K] : never;
+type GetFunction<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    <K extends QueryTopKey<Q>>(type: 'query', key: K): MultipleQueryResponse<Q>[K];
+    <K extends QueryCompositeKey<Q>>(type: 'query', key: K): QueryValue<Q, K>;
+    <K extends QueryCompositeKey<Q>>(type: 'query', key: K, defaultValue: unknown): NonNullable<QueryValue<Q, K>>;
+    <K extends QueryTopKey<Q>>(type: 'query', key: K, defaultValue: MultipleQueryResponse<Q>[K]['data']): MultipleQueryResponse<Q>[K]['data'];
+    <K extends QueryCompositeKey<Q>>(type: 'query', key: K, defaultValue: QueryValue<Q, K>): NonNullable<QueryValue<Q, K>>;
+    <K extends MutationTopKey<Q>>(type: 'mutation', key: K): AllMutation<Q>[K];
+    <K extends MutationCompositeKey<Q>>(type: 'mutation', key: K): MutationValue<Q, K>;
+    <K extends MutationCompositeKey<Q>>(type: 'mutation', key: K, defaultValue: unknown): NonNullable<MutationValue<Q, K>>;
+    <K extends MutationTopKey<Q>>(type: 'mutation', key: K, defaultValue: AllMutation<Q>[K]['data']): AllMutation<Q>[K]['data'];
+    <K extends MutationCompositeKey<Q>>(type: 'mutation', key: K, defaultValue: MutationValue<Q, K>): NonNullable<MutationValue<Q, K>>;
+    <K extends VariableTopKey<V>>(type: 'state', key: K): VariableValue<V, K>;
+    <K extends VariableTopKey<V>>(type: 'state', key: K, defaultValue: VariableValue<V, K>): NonNullable<VariableValue<V, K>>;
+    <TField extends DeepKeys<F>>(type: 'form', key: TField): DeepValue<F, TField> | undefined;
+    <TField extends DeepKeys<F>>(type: 'form', key: TField, defaultValue: DeepValue<F, TField>): NonNullable<DeepValue<F, TField>>;
+};
+type SetFunction<F extends FieldValues, V extends Record<string, unknown> = Record<string, unknown>> = {
+    (type: 'form'): SetValueFunction<F>;
+    (type: 'state'): <K extends VariableTopKey<V>>(key: K, value: VariableValue<V, K>) => void;
+};
+type FunctionProps<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    /**
+     * Read the current query/mutation value by key.
+     * Example: get('query', 'bookings')
+     */
+    get: GetFunction<F, Q, V>;
+    /**
+     * Generic setter accessor.
+     * - set('form') returns `setValue`
+     * - set('state') returns state setter
+     */
+    set: SetFunction<F, V>;
+};
+type MappedItemsFunction<F extends FieldValues, Q extends QueriesArray, ComponentType, V extends Record<string, unknown> = Record<string, unknown>> = (props: FunctionProps<F, Q, V>) => ComponentType;
+/**
+ * Context passed to lifecycle callbacks
+ * Provides access to form, queries, mutations, and utilities
+ */
+type LifecycleContext<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = FunctionProps<F, Q, V> & {
+    ns?: string;
+    pageId?: string;
+    pageConfig?: PageProps<F, Q, V>;
+};
+type Items<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'custom';
+    component: React.JSX.Element | ((props: FunctionProps<F, Q, V>) => React.JSX.Element);
+    index?: number;
+    usedBoxes?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    hidden?: boolean | MappedItemsFunction<F, Q, boolean, V>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    key?: string;
+    lazy?: boolean;
+    lazyTrigger?: 'viewport' | 'interaction' | 'conditional';
+    lazyCondition?: MappedItemsFunction<F, Q, boolean, V>;
+};
+type ContainerItem<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'container';
+    component?: PageConfigProps['ItemsContainer'];
+    items: ContentItemsType<F, Q, V>;
+    index?: number;
+    usedBoxes?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    hidden?: boolean | MappedItemsFunction<F, Q, boolean, V>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    key?: string;
+    lazy?: boolean;
+    lazyTrigger?: 'viewport' | 'interaction' | 'conditional';
+    lazyCondition?: MappedItemsFunction<F, Q, boolean, V>;
+};
+type ContentItem<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Items<F, Q, V> | ContainerItem<F, Q, V>;
+type MappedContents<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = MappedItemsFunction<F, Q, Array<ContentItem<F, Q, V>>, V>;
+type ContentItemsType<F extends FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Array<ContentItem<F, Q, V>> | MappedContents<F, Q, V>;
+type FormPageProps<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Omit<ComponentProps<typeof FormManager<F>>, 'updateFormValues' | 'submit' | 'data'> & {
+    defaultValueQueryKey?: Array<string>;
+    defaultValueQueryMap?: (props: ExtractQuery<Q>['response']) => DeepValue<F, DeepKeys<F>>;
+    submit?: Array<Submit<F>> | MappedItemsFunction<F, Q, Array<Submit<F>>, V>;
+    index?: number;
+    data?: Array<FormManagerConfig<F> | MappedItemsFunction<F, Q, FormManagerConfig<F>, V>>;
+    debounceDelay?: number;
+    hidden?: boolean | MappedItemsFunction<F, Q, boolean, V>;
+};
+type SingleQueryConfig<F extends FieldValues, Q extends QueryDefinition<any, any, any, any, any>, V extends Record<string, unknown> = Record<string, unknown>> = Q extends QueryDefinition<infer K, infer T, infer P, infer R, infer C> ? T extends 'mutation' ? {
+    type: 'mutation';
+    mutationConfig: (<Qa extends QueriesArray>(props: FunctionProps<F, Qa, V>) => MutationConfig<P, R, C>) | MutationConfig<P, R, C>;
+    key: K;
+} : {
+    type: 'query';
+    queryConfig?: (<Qa extends QueriesArray>(props: FunctionProps<F, Qa, V>) => Omit<QueryProps<K, R>, 'keyToMap'>) | Omit<QueryProps<K, R>, 'keyToMap'>;
+    key: K;
+} : never;
+type QueryPageConfigArray<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    [I in keyof Q]: SingleQueryConfig<F, QueryAtIndex<Q, I>, V>;
+};
+interface PageProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    ns?: string;
+    contents?: ContentItemsType<F, Q, V>;
+    queries?: QueryPageConfigArray<F, Q, V>;
+    form?: FormPageProps<F, Q, V>;
+    variables?: V;
+    viewSettings?: MappedItemsFunction<F, Q, ViewSettings, V> | ViewSettings;
+    meta?: MetadataConfig<F, Q>;
+    lazyLoading?: LazyLoadingConfig;
+    platformOverrides?: PlatformOverrides<F, Q, V>;
+    lifecycleCallbacks?: {
+        onMountComplete?: (context: LifecycleContext<F, Q, V>) => void | Promise<void>;
+        onQuerySuccess?: (context: LifecycleContext<F, Q, V>, queryKey: string, data: unknown) => void | Promise<void>;
+        onQueryError?: (context: LifecycleContext<F, Q, V>, queryKey: string, error: Error) => void | Promise<void>;
+        onFormSubmit?: (context: LifecycleContext<F, Q, V>, result: unknown) => void | Promise<void>;
+        onValuesChange?: MappedItemsFunction<F, Q, void, V>;
+    };
+    enableAuthControl?: boolean;
+}
+/**
+ * Platform-specific configuration overrides (proper type with PageProps reference)
+ * Allows different behavior on web vs React Native
+ */
+type PlatformOverrides<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Web-specific overrides (React DOM) */
+    web?: Partial<PageProps<F, Q, V>>;
+    /** React Native-specific overrides */
+    native?: Partial<PageProps<F, Q, V>>;
+};
+type ViewSettings = {
+    withoutPadding?: boolean;
+    header?: {
+        withoutPadding?: boolean;
+    };
+    footer?: {
+        withoutPadding?: boolean;
+    };
+    disableRefreshing?: boolean;
+    layoutComponent?: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: DefaultContainerProps<F, Q, V> & Record<string, unknown>) => React.ReactNode;
+    layoutProps?: Record<string, unknown>;
+    pageContainerComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        id: string;
+    } & Record<string, unknown>>;
+    pageContainerProps?: Record<string, unknown>;
+    /** @deprecated Use layoutComponent instead */
+    customLayoutComponent?: PageConfigProps['BodyContainer'];
+    /** @deprecated Use pageContainerComponent instead */
+    customPageContainer?: PageConfigProps['PageContainer'];
+};
+/**
+ * Dependency Graph Node
+ * Tracks which queries, form values, and mutations a component depends on
+ */
+interface DependencyNode {
+    componentId: string;
+    parentComponent: string | null;
+    childComponents: Array<string>;
+}
+/**
+ * Dependency Graph
+ * Maps component IDs to their dependency nodes for selective re-rendering
+ */
+interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    addNode: (node: DependencyNode) => void;
+    getNode: (componentId: string) => DependencyNode | undefined;
+    getAffectedComponents: (changedKeys: Array<string>) => Array<string>;
+}
+/**
+ * Memoization Cache Types
+ * For tracking memoized computations and their cache hits
+ */
+interface MemoizationCacheStats {
+    hits: number;
+    misses: number;
+    size: number;
+    maxSize: number;
+}
+interface RenderComponentsProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    content: ContentItem<F, Q, V>;
+    ns: string;
+    pageId: string;
+    key: string;
+}
+
+declare const PageGenerator: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ enableAuthControl, meta, variables, ...props }: PageProps<F, Q, V>) => react_jsx_runtime.JSX.Element;
+
+declare const RenderComponents: <F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: RenderComponentsProps<F, Q, V>) => react_jsx_runtime.JSX.Element;
+
+interface Props<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    content: ContentItem<F, Q, V>;
+    ns: string;
+    pageId: string;
+}
+interface ContentProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> extends Omit<Props<F, Q, V>, 'content'> {
+    content: Items<F, Q, V>;
+    pageId: string;
+}
+interface ItemContainerProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> extends Omit<Props<F, Q, V>, 'content'> {
+    content: ContainerItem<F, Q, V>;
+}
+
+/**
+ * Metadata Configuration Types
+ * Custom metadata system replacing react-helmet-async
+ * Platform-agnostic: works on web, React Native, and SSR
+ */
+
+/**
+ * Context passed to dynamic metadata evaluator functions
+ * Provides access to form values, queries, and page state
+ */
+type MetadataEvaluatorContext$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> = FunctionProps$1<F, Q>;
+interface MetaTag$1 {
+    /** For <meta name="..." content="..." /> */
+    name?: string;
+    /** For <meta property="og:..." content="..." /> */
+    property?: string;
+    /** For <meta http-equiv="..." content="..." /> */
+    httpEquiv?: string;
+    /** Meta tag content */
+    content: string;
+    /** Unique identifier for updating existing tags */
+    id?: string;
+}
+/**
+ * Open Graph Image Configuration
+ */
+interface OpenGraphImage$1 {
+    /** Absolute URL to the image */
+    url: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** Image width in pixels */
+    width?: number;
+    /** Image height in pixels */
+    height?: number;
+    /** MIME type (e.g., "image/jpeg", "image/png") */
+    type?: string;
+}
+/**
+ * Open Graph Article Configuration (when type='article')
+ */
+interface OpenGraphArticle$1 {
+    /** ISO 8601 date string */
+    publishedTime?: string;
+    /** ISO 8601 date string */
+    modifiedTime?: string;
+    /** ISO 8601 date string */
+    expirationTime?: string;
+    /** Author name or URL */
+    author?: string | Array<string>;
+    /** Article section/category */
+    section?: string;
+    /** Article tags */
+    tags?: Array<string>;
+}
+/**
+ * Open Graph Configuration (Facebook, LinkedIn, etc.)
+ */
+interface OpenGraphConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    type?: 'website' | 'article' | 'product' | 'profile';
+    title?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    description?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Single image URL or full image config */
+    image?: string | OpenGraphImage$1 | ((context: MetadataEvaluatorContext$1<F, Q>) => string | OpenGraphImage$1);
+    /** Multiple images for the page */
+    images?: Array<OpenGraphImage$1> | ((context: MetadataEvaluatorContext$1<F, Q>) => Array<OpenGraphImage$1>);
+    /** Canonical URL */
+    url?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    siteName?: string;
+    /** Locale (e.g., "en_US", "it_IT") */
+    locale?: string;
+    /** Article-specific metadata (when type='article') */
+    article?: OpenGraphArticle$1;
+}
+/**
+ * Twitter Card Configuration
+ */
+interface TwitterCardConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Card type */
+    card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    /** @username of the website */
+    site?: string;
+    /** @username of the content creator */
+    creator?: string;
+    /** Title (falls back to og:title then page title) */
+    title?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Description (falls back to og:description then page description) */
+    description?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Image URL (falls back to og:image) */
+    image?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Alt text for the image */
+    imageAlt?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+}
+/**
+ * Alternate languages/URLs configuration for i18n SEO
+ */
+interface AlternatesConfig$1 {
+    /** Canonical URL for this page */
+    canonical?: string;
+    /** Map of locale → URL for hreflang tags (e.g., { "en": "/en/page", "it": "/it/page" }) */
+    languages?: Record<string, string>;
+    /** Media-specific alternates (e.g., mobile version) */
+    media?: Record<string, string>;
+    /** RSS/Atom feed alternates */
+    types?: Record<string, Array<{
+        url: string;
+        title?: string;
+    }>>;
+}
+/**
+ * Icon configuration
+ */
+interface IconConfig$1 {
+    /** URL to the icon */
+    url: string;
+    /** Icon type (e.g., "image/png", "image/svg+xml") */
+    type?: string;
+    /** Icon sizes (e.g., "32x32", "192x192") */
+    sizes?: string;
+    /** Color for SVG mask icons */
+    color?: string;
+}
+/**
+ * Icons & PWA configuration
+ */
+interface IconsConfig$1 {
+    /** Standard favicon(s) - link[rel="icon"] */
+    icon?: string | IconConfig$1 | Array<IconConfig$1>;
+    /** Apple touch icon(s) - link[rel="apple-touch-icon"] */
+    apple?: string | IconConfig$1 | Array<IconConfig$1>;
+    /** Shortcut icon (legacy) */
+    shortcut?: string;
+}
+/**
+ * Structured Data Configuration (schema.org JSON-LD)
+ */
+interface StructuredDataConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    type: 'Article' | 'Product' | 'WebPage' | 'FAQPage' | 'Organization' | 'Person' | 'WebSite' | 'BreadcrumbList';
+    schema: Record<string, unknown> | ((context: MetadataEvaluatorContext$1<F, Q>) => Record<string, unknown>);
+}
+/**
+ * AI Crawler Hints (for AI search engines and LLMs)
+ */
+interface AIHintsConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Content classification (e.g., "documentation", "tutorial", "reference") */
+    contentClassification?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Hints for AI models (e.g., ["code-heavy", "technical"]) */
+    modelHints?: Array<string> | ((context: MetadataEvaluatorContext$1<F, Q>) => Array<string>);
+    /** Additional context for AI understanding */
+    contextualInfo?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Exclude this page from AI crawler indexing */
+    excludeFromIndexing?: boolean;
+}
+/**
+ * Robots Configuration (indexing directives)
+ */
+interface RobotsConfig$1 {
+    /** Prevent indexing */
+    noindex?: boolean;
+    /** Don't follow links */
+    nofollow?: boolean;
+    /** Don't cache page */
+    noarchive?: boolean;
+    /** Don't show snippets in search results */
+    nosnippet?: boolean;
+    /** Image preview size in search results */
+    maxImagePreview?: 'none' | 'standard' | 'large';
+    /** Max snippet length in search results */
+    maxSnippet?: number;
+}
+/**
+ * Complete Metadata Configuration (Generic over F and Q for dynamic metadata)
+ * This is the "input" type — values can be strings or evaluator functions.
+ * Use resolveMetadata() to convert this to ResolvedMetadata.
+ */
+interface MetadataConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Page title - sets document.title on web */
+    title?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Page description meta tag */
+    description?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** Canonical URL for the page */
+    canonical?: string | ((context: MetadataEvaluatorContext$1<F, Q>) => string);
+    /** HTML lang attribute (e.g., "en", "it") */
+    lang?: string;
+    /**
+     * @deprecated Use `lang` instead. Will be removed in a future version.
+     */
+    documentLang?: string;
+    /** Keywords for SEO */
+    keywords?: Array<string> | ((context: MetadataEvaluatorContext$1<F, Q>) => Array<string>);
+    openGraph?: OpenGraphConfig$1<F, Q>;
+    twitter?: TwitterCardConfig$1<F, Q>;
+    alternates?: AlternatesConfig$1;
+    icons?: IconsConfig$1;
+    /** Web app manifest URL */
+    manifest?: string;
+    structuredData?: StructuredDataConfig$1<F, Q>;
+    aiHints?: AIHintsConfig$1<F, Q>;
+    robots?: RobotsConfig$1;
+    customMeta?: Array<MetaTag$1> | ((context: MetadataEvaluatorContext$1<F, Q>) => Array<MetaTag$1>);
+    disableIndexing?: boolean;
+    /** Author meta tag */
+    author?: string;
+    /** Viewport meta tag (defaults to "width=device-width, initial-scale=1") */
+    viewport?: string;
+    /** Theme color for browser UI */
+    themeColor?: string;
+}
+/**
+ * Configuration for lazy loading and code splitting behavior
+ * Enables deferred component loading to reduce initial bundle size
+ */
+interface LazyLoadingConfig$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Enable lazy loading (default: true) */
+    enabled?: boolean;
+    /** Preload on hover for interactive elements (default: false) */
+    preloadOnHover?: boolean;
+    /** Preload on focus for keyboard navigation (default: false) */
+    preloadOnFocus?: boolean;
+    /** Preload after render with delay (in ms, default: undefined - no delay) */
+    preloadAfterRender?: number;
+    /** Fallback component to show while loading (default: null) */
+    suspenseFallback?: React.ReactNode;
+    /** Custom error boundary component for lazy-loaded modules */
+    errorBoundary?: React.ComponentType<{
+        error: Error;
+        retry: () => void;
+    }>;
+    /** Maximum time to wait before showing error state (in ms, default: 30000) */
+    timeout?: number;
+    /** Log performance metrics for lazy loading (development only) */
+    logMetrics?: boolean;
+    /** IntersectionObserver threshold (0-1, default: 0.1) - alias for intersectionThreshold */
+    threshold?: number | Array<number>;
+    /** IntersectionObserver threshold (0-1, default: 0.1) */
+    intersectionThreshold?: number | Array<number>;
+    /** IntersectionObserver root margin (default: "100px") - alias for intersectionRootMargin */
+    rootMargin?: string;
+    /** IntersectionObserver root margin (default: "100px") */
+    intersectionRootMargin?: string;
+    /** Trigger type for lazy loading: viewport (IntersectionObserver), interaction (manual), or conditional (based on function) */
+    trigger?: 'viewport' | 'interaction' | 'conditional';
+    /** Conditional function to determine if content should load (for trigger: "conditional") */
+    condition?: (context: MetadataEvaluatorContext$1<F, Q>) => boolean;
+    /** Placeholder component to show before lazy content loads */
+    placeholder?: React.ReactNode;
+}
+
+interface DefaultContainerProps$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    children?: Array<React.JSX.Element>;
+    allContents: Array<ContentItem$1<F, Q, V> | FormManagerConfig<F> | Submit<F>>;
+    handleRefresh?: () => void;
+    viewSettings?: ViewSettings$1;
+    pageId?: string;
+}
+type PageAuthState$1 = {
+    id: string;
+    accountVerified?: boolean;
+    isLogged?: boolean;
+    token?: string;
+    phoneNumber?: string;
+    email?: string;
+};
+interface PageTranslationOptions$1 {
+    [key: string]: string | number | boolean | undefined;
+    ns?: string;
+}
+interface PageConfigProps$1 {
+    HeaderContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps$1<F, Q, V>, 'viewSettings'> & ViewSettings$1['header']) => React.ReactNode;
+    FooterContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps$1<F, Q, V>, 'viewSettings'> & ViewSettings$1['footer']) => React.ReactNode;
+    BodyContainer: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: DefaultContainerProps$1<F, Q, V>) => React.ReactNode;
+    authPageImage: string;
+    authPageProps: PageProps$1;
+    isLogged: (val: AuthState | null) => boolean;
+    ItemsContainer: (props: {
+        children: React.ReactNode;
+    }) => React.ReactNode;
+    LoaderComponent?: (props: {
+        loading?: boolean;
+        message?: string;
+        ns?: string;
+    }) => React.ReactNode;
+    PageContainer: (props: {
+        children: React.ReactNode;
+        id: string;
+    }) => React.ReactNode;
+    meta?: {
+        title?: string;
+        description?: string;
+    };
+    defaultMetadata: MetadataConfig$1;
+    setMetadata: (config: MetadataConfig$1) => void;
+    getMetadata: () => MetadataConfig$1;
+    resetMetadata: () => void;
+    lazyLoading: LazyLoadingConfig$1;
+    authValues?: PageAuthState$1 | null;
+    locale?: string;
+    translateText?: (key: string, options?: PageTranslationOptions$1) => string;
+}
+
+type StringKey$1<T> = Extract<keyof T, string>;
+type VariableTopKey$1<V> = StringKey$1<V>;
+type VariableValue$1<V, K extends VariableTopKey$1<V>> = V[K];
+type QueryTopKey$1<Q extends QueriesArray> = StringKey$1<MultipleQueryResponse<Q>>;
+type QuerySubKey$1<Q extends QueriesArray, K extends QueryTopKey$1<Q>> = StringKey$1<MultipleQueryResponse<Q>[K]>;
+type QueryCompositeKey$1<Q extends QueriesArray> = {
+    [K in QueryTopKey$1<Q>]: K | `${K}.${QuerySubKey$1<Q, K>}`;
+}[QueryTopKey$1<Q>];
+type QueryValue$1<Q extends QueriesArray, K extends QueryCompositeKey$1<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends QueryTopKey$1<Q> ? Sub extends QuerySubKey$1<Q, Top> ? MultipleQueryResponse<Q>[Top][Sub] : never : never : K extends QueryTopKey$1<Q> ? MultipleQueryResponse<Q>[K] : never;
+type MutationTopKey$1<Q extends QueriesArray> = StringKey$1<AllMutation<Q>>;
+type MutationSubKey$1<Q extends QueriesArray, K extends MutationTopKey$1<Q>> = StringKey$1<AllMutation<Q>[K]>;
+type MutationCompositeKey$1<Q extends QueriesArray> = {
+    [K in MutationTopKey$1<Q>]: K | `${K}.${MutationSubKey$1<Q, K>}`;
+}[MutationTopKey$1<Q>];
+type MutationValue$1<Q extends QueriesArray, K extends MutationCompositeKey$1<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends MutationTopKey$1<Q> ? Sub extends MutationSubKey$1<Q, Top> ? AllMutation<Q>[Top][Sub] : never : never : K extends MutationTopKey$1<Q> ? AllMutation<Q>[K] : never;
+type GetFunction$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    <K extends QueryTopKey$1<Q>>(type: 'query', key: K): MultipleQueryResponse<Q>[K];
+    <K extends QueryCompositeKey$1<Q>>(type: 'query', key: K): QueryValue$1<Q, K>;
+    <K extends QueryCompositeKey$1<Q>>(type: 'query', key: K, defaultValue: unknown): NonNullable<QueryValue$1<Q, K>>;
+    <K extends QueryTopKey$1<Q>>(type: 'query', key: K, defaultValue: MultipleQueryResponse<Q>[K]['data']): MultipleQueryResponse<Q>[K]['data'];
+    <K extends QueryCompositeKey$1<Q>>(type: 'query', key: K, defaultValue: QueryValue$1<Q, K>): NonNullable<QueryValue$1<Q, K>>;
+    <K extends MutationTopKey$1<Q>>(type: 'mutation', key: K): AllMutation<Q>[K];
+    <K extends MutationCompositeKey$1<Q>>(type: 'mutation', key: K): MutationValue$1<Q, K>;
+    <K extends MutationCompositeKey$1<Q>>(type: 'mutation', key: K, defaultValue: unknown): NonNullable<MutationValue$1<Q, K>>;
+    <K extends MutationTopKey$1<Q>>(type: 'mutation', key: K, defaultValue: AllMutation<Q>[K]['data']): AllMutation<Q>[K]['data'];
+    <K extends MutationCompositeKey$1<Q>>(type: 'mutation', key: K, defaultValue: MutationValue$1<Q, K>): NonNullable<MutationValue$1<Q, K>>;
+    <K extends VariableTopKey$1<V>>(type: 'state', key: K): VariableValue$1<V, K>;
+    <K extends VariableTopKey$1<V>>(type: 'state', key: K, defaultValue: VariableValue$1<V, K>): NonNullable<VariableValue$1<V, K>>;
+    <TField extends DeepKeys<F>>(type: 'form', key: TField): DeepValue<F, TField> | undefined;
+    <TField extends DeepKeys<F>>(type: 'form', key: TField, defaultValue: DeepValue<F, TField>): NonNullable<DeepValue<F, TField>>;
+};
+type SetFunction$1<F extends FieldValues, V extends Record<string, unknown> = Record<string, unknown>> = {
+    (type: 'form'): SetValueFunction<F>;
+    (type: 'state'): <K extends VariableTopKey$1<V>>(key: K, value: VariableValue$1<V, K>) => void;
+};
+type FunctionProps$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    /**
+     * Read the current query/mutation value by key.
+     * Example: get('query', 'bookings')
+     */
+    get: GetFunction$1<F, Q, V>;
+    /**
+     * Generic setter accessor.
+     * - set('form') returns `setValue`
+     * - set('state') returns state setter
+     */
+    set: SetFunction$1<F, V>;
+};
+type MappedItemsFunction$1<F extends FieldValues, Q extends QueriesArray, ComponentType, V extends Record<string, unknown> = Record<string, unknown>> = (props: FunctionProps$1<F, Q, V>) => ComponentType;
+/**
+ * Context passed to lifecycle callbacks
+ * Provides access to form, queries, mutations, and utilities
+ */
+type LifecycleContext$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = FunctionProps$1<F, Q, V> & {
+    ns?: string;
+    pageId?: string;
+    pageConfig?: PageProps$1<F, Q, V>;
+};
+type Items$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'custom';
+    component: React.JSX.Element | ((props: FunctionProps$1<F, Q, V>) => React.JSX.Element);
+    index?: number;
+    usedBoxes?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    hidden?: boolean | MappedItemsFunction$1<F, Q, boolean, V>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    key?: string;
+    lazy?: boolean;
+    lazyTrigger?: 'viewport' | 'interaction' | 'conditional';
+    lazyCondition?: MappedItemsFunction$1<F, Q, boolean, V>;
+};
+type ContainerItem$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'container';
+    component?: PageConfigProps$1['ItemsContainer'];
+    items: ContentItemsType$1<F, Q, V>;
+    index?: number;
+    usedBoxes?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    hidden?: boolean | MappedItemsFunction$1<F, Q, boolean, V>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    key?: string;
+    lazy?: boolean;
+    lazyTrigger?: 'viewport' | 'interaction' | 'conditional';
+    lazyCondition?: MappedItemsFunction$1<F, Q, boolean, V>;
+};
+type ContentItem$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Items$1<F, Q, V> | ContainerItem$1<F, Q, V>;
+type MappedContents$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = MappedItemsFunction$1<F, Q, Array<ContentItem$1<F, Q, V>>, V>;
+type ContentItemsType$1<F extends FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Array<ContentItem$1<F, Q, V>> | MappedContents$1<F, Q, V>;
+type FormPageProps$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = Omit<ComponentProps<typeof FormManager<F>>, 'updateFormValues' | 'submit' | 'data'> & {
+    defaultValueQueryKey?: Array<string>;
+    defaultValueQueryMap?: (props: ExtractQuery<Q>['response']) => DeepValue<F, DeepKeys<F>>;
+    submit?: Array<Submit<F>> | MappedItemsFunction$1<F, Q, Array<Submit<F>>, V>;
+    index?: number;
+    data?: Array<FormManagerConfig<F> | MappedItemsFunction$1<F, Q, FormManagerConfig<F>, V>>;
+    debounceDelay?: number;
+    hidden?: boolean | MappedItemsFunction$1<F, Q, boolean, V>;
+};
+type SingleQueryConfig$1<F extends FieldValues, Q extends QueryDefinition<any, any, any, any, any>, V extends Record<string, unknown> = Record<string, unknown>> = Q extends QueryDefinition<infer K, infer T, infer P, infer R, infer C> ? T extends 'mutation' ? {
+    type: 'mutation';
+    mutationConfig: (<Qa extends QueriesArray>(props: FunctionProps$1<F, Qa, V>) => MutationConfig<P, R, C>) | MutationConfig<P, R, C>;
+    key: K;
+} : {
+    type: 'query';
+    queryConfig?: (<Qa extends QueriesArray>(props: FunctionProps$1<F, Qa, V>) => Omit<QueryProps<K, R>, 'keyToMap'>) | Omit<QueryProps<K, R>, 'keyToMap'>;
+    key: K;
+} : never;
+type QueryPageConfigArray$1<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    [I in keyof Q]: SingleQueryConfig$1<F, QueryAtIndex<Q, I>, V>;
+};
+interface PageProps$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    ns?: string;
+    contents?: ContentItemsType$1<F, Q, V>;
+    queries?: QueryPageConfigArray$1<F, Q, V>;
+    form?: FormPageProps$1<F, Q, V>;
+    variables?: V;
+    viewSettings?: MappedItemsFunction$1<F, Q, ViewSettings$1, V> | ViewSettings$1;
+    meta?: MetadataConfig$1<F, Q>;
+    lazyLoading?: LazyLoadingConfig$1;
+    platformOverrides?: PlatformOverrides$1<F, Q, V>;
+    lifecycleCallbacks?: {
+        onMountComplete?: (context: LifecycleContext$1<F, Q, V>) => void | Promise<void>;
+        onQuerySuccess?: (context: LifecycleContext$1<F, Q, V>, queryKey: string, data: unknown) => void | Promise<void>;
+        onQueryError?: (context: LifecycleContext$1<F, Q, V>, queryKey: string, error: Error) => void | Promise<void>;
+        onFormSubmit?: (context: LifecycleContext$1<F, Q, V>, result: unknown) => void | Promise<void>;
+        onValuesChange?: MappedItemsFunction$1<F, Q, void, V>;
+    };
+    enableAuthControl?: boolean;
+}
+/**
+ * Platform-specific configuration overrides (proper type with PageProps reference)
+ * Allows different behavior on web vs React Native
+ */
+type PlatformOverrides$1<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Web-specific overrides (React DOM) */
+    web?: Partial<PageProps$1<F, Q, V>>;
+    /** React Native-specific overrides */
+    native?: Partial<PageProps$1<F, Q, V>>;
+};
+type ViewSettings$1 = {
+    withoutPadding?: boolean;
+    header?: {
+        withoutPadding?: boolean;
+    };
+    footer?: {
+        withoutPadding?: boolean;
+    };
+    disableRefreshing?: boolean;
+    layoutComponent?: <F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>(props: DefaultContainerProps$1<F, Q, V> & Record<string, unknown>) => React.ReactNode;
+    layoutProps?: Record<string, unknown>;
+    pageContainerComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        id: string;
+    } & Record<string, unknown>>;
+    pageContainerProps?: Record<string, unknown>;
+    /** @deprecated Use layoutComponent instead */
+    customLayoutComponent?: PageConfigProps$1['BodyContainer'];
+    /** @deprecated Use pageContainerComponent instead */
+    customPageContainer?: PageConfigProps$1['PageContainer'];
+};
+
+declare const usePageConfig: <F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ queries, form, ns, viewSettings, meta, lazyLoading, variables, pageId, }: {
+    queries: QueryPageConfigArray<F, Q, V>;
+    form?: FormPageProps<F, Q, V>;
+    ns: string;
+    viewSettings?: MappedItemsFunction<F, Q, ViewSettings, V> | ViewSettings;
+    meta?: MetadataConfig<F, Q>;
+    lazyLoading?: LazyLoadingConfig;
+    variables?: V;
+    pageId: string;
+}) => {
+    formData: {
+        formContents: (_gaddario98_react_form.Submit<F, _gaddario98_react_form.SubmitKeysArg<F>> | _gaddario98_react_form.FormManagerConfig<F>)[];
+        elements: _gaddario98_react_form.FormElements[];
+        errors: any[];
+        formValues: F;
+        setValue: _gaddario98_react_form.SetValueFunction<F>;
+    };
+    form: FormPageProps<F, Q, V> | undefined;
+    mappedViewSettings: ViewSettings;
+    meta: MetadataConfig<F, Q> | undefined;
+    lazyLoading: LazyLoadingConfig<FieldValues, QueriesArray> | undefined;
+    globalConfig: PageConfigProps$1;
+};
+
+interface GenerateContentProps<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    pageId: string;
+    ns?: string;
+    contents: ContentItemsType<F, Q, V>;
+    pageConfig: ReturnType<typeof usePageConfig<F, Q, V>>;
+}
+declare const useGenerateContent: <F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ pageId, ns, contents, pageConfig, }: GenerateContentProps<F, Q, V>) => {
+    header: react_jsx_runtime.JSX.Element[];
+    body: react_jsx_runtime.JSX.Element[];
+    footer: react_jsx_runtime.JSX.Element[];
+    allContents: (ContentItem$1<F, Q, V> | _gaddario98_react_form.Submit<F, _gaddario98_react_form.SubmitKeysArg<F>> | _gaddario98_react_form.FormManagerConfig<F>)[];
+};
+
+interface GenerateContentRenderProps<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>> {
+    contents?: ContentItemsType<F, Q, V>;
+    ns?: string;
+    pageId: string;
+    formData: {
+        formContents: Array<Submit<F, SubmitKeysArg<F>> | FormManagerConfig<F>>;
+        elements: Array<FormElements>;
+        errors: Array<unknown>;
+        formValues: F;
+        setValue: SetValueFunction<F>;
+    };
+}
+interface Elements {
+    index: number;
+    element: JSX.Element;
+    renderInFooter: boolean;
+    renderInHeader: boolean;
+    key: string;
+}
+declare const useGenerateContentRender: <F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ pageId, ns, contents, formData, }: GenerateContentRenderProps<F, Q, V>) => {
+    components: {
+        element: react_jsx_runtime.JSX.Element;
+        index: number;
+        renderInFooter: boolean;
+        renderInHeader: boolean;
+        key: string;
+    }[];
+    allContents: (ContentItem<F, Q, V> | Submit<F, SubmitKeysArg<F>> | FormManagerConfig<F>)[];
+};
+
+/**
+ * Specialized hook for managing view settings
+ * Optimized to prevent unnecessary re-renders
+ * @param viewSettings - View settings configuration (static or function)
+ * @param allQuery - All query results
+ * @param allMutation - All mutation handlers
+ * @param formValues - Current form values
+ * @param setValue - Form setValue function
+ * @returns Processed view settings
+ */
+declare function useViewSettings<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ viewSettings, pageId, }: {
+    viewSettings?: MappedItemsFunction<F, Q, ViewSettings, V> | ViewSettings;
+    pageId: string;
+}): ViewSettings;
+
+/**
+ * Specialized hook for managing form data processing
+ * Uses useMemo to prevent unnecessary re-computation
+ * @param form - Form configuration
+ * @param isAllQueryMapped - Whether all queries are mapped
+ * @param formValues - Current form values
+ * @param extractMutationsHandle - Extracted mutations
+ * @param extractQueryHandle - Extracted queries
+ * @param setValue - Form setValue function
+ * @returns Processed form data and submit handlers
+ */
+declare function useFormData<F extends FieldValues, Q extends QueriesArray, V extends Record<string, unknown> = Record<string, unknown>>({ form, pageId }: {
+    form?: FormPageProps<F, Q, V>;
+    pageId: string;
+}): {
+    mappedFormData: FormManagerConfig<F>[];
+    formSubmit: Submit<F, _gaddario98_react_form.SubmitKeysArg<F>>[];
+};
+
+/**
+ * useMetadata Hook
+ * Evaluates dynamic metadata with query data and form values
+ * Integrates i18n for metadata translation
+ * Uses resolveMetadata + applyMetadataToDom for clean separation
+ *
+ * @module hooks/useMetadata
+ */
+
+/**
+ * Props for useMetadata hook
+ */
+interface UseMetadataProps<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray> {
+    /** Base metadata configuration (static or dynamic function) */
+    meta?: MetadataConfig<F, Q> | MappedItemsFunction<F, Q, MetadataConfig>;
+    /** Namespace for i18n translations */
+    ns?: string;
+    /** Whether to automatically apply metadata (default: true) */
+    autoApply?: boolean;
+    pageId: string;
+}
+/**
+ * Hook for evaluating and managing dynamic metadata.
+ *
+ * Pipeline:
+ * 1. Evaluate `meta` (if it's a MappedItemsFunction, call it with get/set)
+ * 2. Resolve all dynamic functions via `resolveMetadata()`
+ * 3. Translate strings via i18n
+ * 4. Auto-apply to DOM (client) or store (SSR) via `applyMetadataToDom` / MetadataStore
+ *
+ * @returns Resolved and translated metadata
+ */
+declare function useMetadata<F extends FieldValues = FieldValues, Q extends QueriesArray = QueriesArray>({ meta, autoApply, pageId }: UseMetadataProps<F, Q>): ResolvedMetadata;
+/**
+ * Hook to manually apply metadata (when autoApply is false)
+ * @returns Function to apply resolved metadata to the DOM
+ */
+declare function useApplyMetadata(): (meta: ResolvedMetadata) => void;
+
+/**
+ * Optimized shallow equality check for objects and functions
+ * @param objA - First object to compare
+ * @param objB - Second object to compare
+ * @returns True if objects are shallow equal
+ */
+declare function shallowEqual(objA: any, objB: any): boolean;
+/**
+ * Checks if a value is stable for React dependency arrays
+ * @param value - Value to check for stability
+ * @returns True if value is considered stable
+ */
+declare function isStableValue(value: any): boolean;
+/**
+ * Creates an optimized dependency array by filtering unstable values
+ * @param deps - Array of dependencies to optimize
+ * @returns Filtered array of stable dependencies
+ */
+declare function optimizeDeps(deps: Array<any>): Array<any>;
+/**
+ * Custom prop comparator for React.memo() to prevent unnecessary re-renders
+ * Compares props shallowly and ignores function references if they have the same name
+ * @param prevProps - Previous component props
+ * @param nextProps - Next component props
+ * @returns True if props are equal (component should NOT re-render)
+ */
+declare function memoPropsComparator<P extends Record<string, any>>(prevProps: Readonly<P>, nextProps: Readonly<P>): boolean;
+/**
+ * Deep equality check for complex objects
+ * Use sparingly - prefer shallow equality for performance
+ * Uses fast-deep-equal library for optimized deep comparison with circular reference protection
+ * @param objA - First object
+ * @param objB - Second object
+ * @returns True if objects are deeply equal
+ */
+declare function deepEqual(objA: any, objB: any): boolean;
+/**
+ * Memoization cache for expensive computations
+ * Simple LRU cache with configurable size
+ */
+declare class MemoizationCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    clear(): void;
+}
+/**
+ * Creates a memoized function with custom cache key generator
+ * @param fn - Function to memoize
+ * @param cacheKeyFn - Optional function to generate cache key from arguments
+ * @returns Memoized function
+ */
+declare function memoize<Args extends Array<any>, Result>(fn: (...args: Args) => Result, cacheKeyFn?: (...args: Args) => string): (...args: Args) => Result;
+
+declare const pageVariablesAtomFamily: jotai_family.AtomFamily<string, jotai.PrimitiveAtom<Record<string, unknown>> & {
+    init: Record<string, unknown>;
+}>;
+/**
+ * Global atom storing all page variables.
+ * Key format: "scopeId:pageId"
+ */
+declare const pageVariablesAtom: jotai.PrimitiveAtom<Record<string, Record<string, unknown>>> & {
+    init: Record<string, Record<string, unknown>>;
+};
+/**
+ * Helper to generate composite keys for page variables.
+ */
+declare const getPageVariablesCompositeKey: (scopeId: string, key: string) => string;
+/**
+ * Creates a derived atom for accessing page variables of a specific scope.
+ */
+declare const createScopePageVariablesAtom: (scopeId: string) => jotai.WritableAtom<Record<string, Record<string, unknown>>, [update: Record<string, Record<string, unknown>>], void>;
+
+/**
+ * Next.js Integration Helpers
+ *
+ * Provides helpers for using the pages metadata system with Next.js:
+ * - `toNextMetadata()` — App Router (`generateMetadata`)
+ * - `NextHeadFromMetadata` — Pages Router (`next/head`)
+ *
+ * @module integrations/next
+ */
+
+/**
+ * Subset of Next.js Metadata type that we map to.
+ * Consumers can use this directly as the return type of `generateMetadata`.
+ */
+interface NextMetadata {
+    title?: string;
+    description?: string;
+    keywords?: Array<string>;
+    authors?: Array<{
+        name?: string;
+        url?: string;
+    }>;
+    viewport?: string;
+    themeColor?: string;
+    robots?: string | {
+        index?: boolean;
+        follow?: boolean;
+        noarchive?: boolean;
+        nosnippet?: boolean;
+        'max-image-preview'?: 'none' | 'standard' | 'large';
+        'max-snippet'?: number;
+    };
+    alternates?: {
+        canonical?: string;
+        languages?: Record<string, string>;
+        media?: Record<string, string>;
+        types?: Record<string, string>;
+    };
+    openGraph?: {
+        title?: string;
+        description?: string;
+        url?: string;
+        siteName?: string;
+        locale?: string;
+        type?: string;
+        images?: Array<{
+            url: string;
+            alt?: string;
+            width?: number;
+            height?: number;
+            type?: string;
+        }>;
+        publishedTime?: string;
+        modifiedTime?: string;
+        authors?: Array<string>;
+        section?: string;
+        tags?: Array<string>;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        images?: Array<string | {
+            url: string;
+            alt?: string;
+        }>;
+    };
+    icons?: {
+        icon?: Array<{
+            url: string;
+            type?: string;
+            sizes?: string;
+        }>;
+        apple?: Array<{
+            url: string;
+            type?: string;
+            sizes?: string;
+        }>;
+        shortcut?: string;
+    };
+    manifest?: string;
+    other?: Record<string, string>;
+}
+/**
+ * Convert ResolvedMetadata into a Next.js Metadata object
+ * for use with App Router's `generateMetadata` or `metadata` export.
+ *
+ * @example
+ * ```ts
+ * // app/page.tsx
+ * import { resolveMetadata, toNextMetadata } from '@/core/pages';
+ *
+ * export async function generateMetadata() {
+ *   const resolved = resolveMetadata(pageConfig.meta, context);
+ *   return toNextMetadata(resolved);
+ * }
+ * ```
+ */
+declare function toNextMetadata(resolved: ResolvedMetadata): NextMetadata;
+/**
+ * Convert ResolvedMetadata into an array of React-compatible head tag descriptors
+ * for use with `next/head` in the Pages Router.
+ *
+ * @example
+ * ```tsx
+ * // pages/index.tsx
+ * import Head from 'next/head';
+ * import { toNextHeadTags, resolveMetadata } from '@/core/pages';
+ *
+ * export default function Page() {
+ *   const resolved = resolveMetadata(pageConfig.meta, context);
+ *   const tags = toNextHeadTags(resolved);
+ *   return (
+ *     <>
+ *       <Head>{tags.map(t => t.html)}</Head>
+ *       <PageContent />
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * Each tag has a `key` (for React list rendering) and `html` (raw HTML string).
+ * For a JSX-based approach, use `collectMetadataToHtml` and inject via dangerouslySetInnerHTML.
+ */
+interface HeadTag {
+    key: string;
+    tag: string;
+    attributes: Record<string, string>;
+    content?: string;
+}
+declare function toNextHeadTags(resolved: ResolvedMetadata): Array<HeadTag>;
+
+/**
+ * Sitemap & Robots.txt Generation Helpers
+ *
+ * Provides functions for generating sitemap.xml and robots.txt content
+ * from page metadata. Useful for:
+ * - Next.js App Router `app/sitemap.ts` and `app/robots.ts`
+ * - Any SSR/SSG framework that needs sitemap generation
+ *
+ * @module integrations/sitemap
+ */
+interface SitemapEntry {
+    /** Absolute URL of the page */
+    url: string;
+    /** Last modification date (ISO 8601) */
+    lastModified?: string | Date;
+    /** Change frequency hint */
+    changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    /** Priority (0.0 to 1.0, default 0.5) */
+    priority?: number;
+    /** Alternate language URLs */
+    alternates?: Record<string, string>;
+}
+/**
+ * Generate a sitemap.xml string from a list of entries.
+ *
+ * @example
+ * ```ts
+ * // app/sitemap.ts (Next.js App Router)
+ * import { generateSitemapXml } from '@/core/pages/integrations/sitemap';
+ *
+ * export default function sitemap() {
+ *   return generateSitemapEntries([
+ *     { url: 'https://example.com', changeFrequency: 'daily', priority: 1.0 },
+ *     { url: 'https://example.com/about', changeFrequency: 'monthly', priority: 0.8 },
+ *   ]);
+ * }
+ * ```
+ */
+declare function generateSitemapXml(entries: Array<SitemapEntry>): string;
+/**
+ * Generate structured sitemap entries compatible with Next.js App Router `sitemap()`.
+ * Returns plain objects that Next.js can serialize.
+ */
+declare function generateSitemapEntries(entries: Array<SitemapEntry>): Array<{
+    url: string;
+    lastModified?: Date;
+    changeFrequency?: string;
+    priority?: number;
+}>;
+interface RobotsTxtConfig {
+    /** Rules for specific or all user agents */
+    rules: Array<{
+        /** User agent string (e.g., "*", "Googlebot") */
+        userAgent: string | Array<string>;
+        /** Allowed paths */
+        allow?: Array<string>;
+        /** Disallowed paths */
+        disallow?: Array<string>;
+        /** Crawl delay in seconds */
+        crawlDelay?: number;
+    }>;
+    /** Sitemap URLs to reference */
+    sitemap?: string | Array<string>;
+    /** Host directive */
+    host?: string;
+}
+/**
+ * Generate a robots.txt string from configuration.
+ *
+ * @example
+ * ```ts
+ * // app/robots.ts (Next.js App Router)
+ * import { generateRobotsTxt } from '@/core/pages/integrations/sitemap';
+ *
+ * export default function robots() {
+ *   return generateRobotsTxt({
+ *     rules: [
+ *       { userAgent: '*', allow: ['/'], disallow: ['/admin'] },
+ *       { userAgent: 'Googlebot', allow: ['/'] },
+ *     ],
+ *     sitemap: 'https://example.com/sitemap.xml',
+ *   });
+ * }
+ * ```
+ */
+declare function generateRobotsTxt(config: RobotsTxtConfig): string;
+
+/**
+ * JSON-LD Structured Data Builders
+ *
+ * Helpers to build valid schema.org JSON-LD objects for common types.
+ * These can be passed to MetadataConfig.structuredData.schema or used
+ * directly in a <script type="application/ld+json"> tag.
+ *
+ * @module integrations/jsonld
+ */
+interface OrganizationJsonLdInput {
+    name: string;
+    url: string;
+    logo?: string;
+    description?: string;
+    sameAs?: Array<string>;
+    contactPoint?: {
+        telephone?: string;
+        contactType?: string;
+        email?: string;
+        areaServed?: string | Array<string>;
+        availableLanguage?: string | Array<string>;
+    };
+}
+declare function buildOrganizationJsonLd(input: OrganizationJsonLdInput): Record<string, unknown>;
+interface WebSiteJsonLdInput {
+    name: string;
+    url: string;
+    description?: string;
+    /** Enable sitelinks searchbox */
+    potentialAction?: {
+        /** URL template for search, e.g., "https://example.com/search?q={search_term_string}" */
+        target: string;
+        queryInput: string;
+    };
+}
+declare function buildWebSiteJsonLd(input: WebSiteJsonLdInput): Record<string, unknown>;
+interface BreadcrumbItem {
+    name: string;
+    url: string;
+}
+declare function buildBreadcrumbListJsonLd(items: Array<BreadcrumbItem>): Record<string, unknown>;
+interface ArticleJsonLdInput {
+    headline: string;
+    description?: string;
+    image?: string | Array<string>;
+    datePublished?: string;
+    dateModified?: string;
+    author?: {
+        name: string;
+        url?: string;
+    } | Array<{
+        name: string;
+        url?: string;
+    }>;
+    publisher?: {
+        name: string;
+        logo?: string;
+    };
+    url?: string;
+    mainEntityOfPage?: string;
+}
+declare function buildArticleJsonLd(input: ArticleJsonLdInput): Record<string, unknown>;
+interface FAQItem {
+    question: string;
+    answer: string;
+}
+declare function buildFAQPageJsonLd(items: Array<FAQItem>): Record<string, unknown>;
+interface ProductJsonLdInput {
+    name: string;
+    description?: string;
+    image?: string | Array<string>;
+    brand?: string;
+    sku?: string;
+    offers?: {
+        price: number;
+        priceCurrency: string;
+        availability?: 'InStock' | 'OutOfStock' | 'PreOrder' | 'SoldOut' | 'BackOrder';
+        url?: string;
+        priceValidUntil?: string;
+    };
+    aggregateRating?: {
+        ratingValue: number;
+        reviewCount: number;
+        bestRating?: number;
+        worstRating?: number;
+    };
+}
+declare function buildProductJsonLd(input: ProductJsonLdInput): Record<string, unknown>;
+
+/**
+ * LLMs.txt Generation Support
+ *
+ * Generates `llms.txt` and `llms-full.txt` content following the
+ * llms.txt specification (https://llmstxt.org/).
+ *
+ * The llms.txt file helps LLMs and AI agents discover what a site offers
+ * and where to find key documentation/content.
+ *
+ * @module integrations/llms
+ */
+
+/**
+ * Generate llms.txt content from configuration.
+ *
+ * Format (per spec):
+ * ```
+ * # Site Name
+ *
+ * > Brief description of the site
+ *
+ * ## Docs
+ *
+ * - [Title](url): Description
+ * - [Title](url): Description
+ * ```
+ *
+ * @example
+ * ```ts
+ * const content = generateLlmsTxt({
+ *   siteName: 'My App',
+ *   siteDescription: 'A great application for doing things.',
+ *   entries: [
+ *     { url: '/docs/getting-started', title: 'Getting Started', description: 'How to set up My App' },
+ *     { url: '/docs/api', title: 'API Reference', description: 'Complete API documentation' },
+ *   ],
+ * });
+ * // Write `content` to /llms.txt
+ * ```
+ */
+declare function generateLlmsTxt(config: LlmsTxtConfig): string;
+/**
+ * Generate a full markdown version (llms-full.txt) that includes
+ * more detailed content for each entry.
+ *
+ * This is useful for providing LLMs with the complete documentation
+ * in a single file.
+ */
+declare function generateLlmsFullTxt(config: LlmsTxtConfig, pageContents: Array<{
+    entry: LlmsTxtEntry;
+    markdown: string;
+}>): string;
+/**
+ * Helper to convert a ResolvedMetadata + page text into a clean markdown
+ * representation suitable for llms-full.txt or standalone .md endpoints.
+ *
+ * Strips HTML chrome, keeps headings coherent, and prepends metadata summary.
+ */
+declare function pageToMarkdown(options: {
+    title: string;
+    description?: string;
+    url: string;
+    content: string;
+}): string;
+
+export { MemoizationCache, MetadataStoreProvider, PageGenerator, RenderComponents, applyMetadataToDom, buildArticleJsonLd, buildBreadcrumbListJsonLd, buildFAQPageJsonLd, buildOrganizationJsonLd, buildProductJsonLd, buildWebSiteJsonLd, clearMetadataLog, collectMetadataToHtml, createMetadataStore, createScopePageVariablesAtom, deepEqual, generateLlmsFullTxt, generateLlmsTxt, generateRobotsTxt, generateSitemapEntries, generateSitemapXml, getMetadata, getMetadataLog, getPageConfig, getPageVariablesCompositeKey, isStableValue, logMetadata, memoPropsComparator, memoize, optimizeDeps, pageConfigAtom, pageToMarkdown, pageVariablesAtom, pageVariablesAtomFamily, resetMetadata, resolveMetadata, setMetadata, setMetadataLogging, shallowEqual, toNextHeadTags, toNextMetadata, useApplyMetadata, useFormData, useGenerateContent, useGenerateContentRender, useMetadata, useMetadataStore, usePageConfig, usePageConfigReset, usePageConfigState, usePageConfigValue, useViewSettings };
+export type { AIHintsConfig, AlternatesConfig, ArticleJsonLdInput, BreadcrumbItem, ContainerItem, ContentItem, ContentItemsType, ContentProps, DefaultContainerProps, DependencyGraph, DependencyNode, Elements, FAQItem, FormPageProps, FunctionProps, GenerateContentProps, GenerateContentRenderProps, GetFunction, HeadTag, IconConfig, IconsConfig, ItemContainerProps, Items, LazyLoadingConfig, LlmsTxtConfig, LlmsTxtEntry, MappedContents, MappedItemsFunction, MemoizationCacheStats, MetaTag, MetadataConfig, MetadataProvider, MetadataStore, NextMetadata, OpenGraphArticle, OpenGraphConfig, OpenGraphImage, OrganizationJsonLdInput, PageAuthState, PageConfigProps, MetadataConfig as PageMetadataProps, PageProps, PageTranslationOptions, PlatformOverrides, ProductJsonLdInput, Props, QueryPageConfigArray, RenderComponentsProps, ResolvedMetadata, RobotsConfig, RobotsTxtConfig, SetFunction, SitemapEntry, StructuredDataConfig, TwitterCardConfig, UseMetadataProps, ViewSettings, WebSiteJsonLdInput };