@gaddario98/react-core 2.0.0 → 2.0.2

package/dist/index.d.ts

@@ -1,8 +1,2153 @@
+import { AuthState } from '@gaddario98/react-auth';
 export * from '@gaddario98/react-auth';
-export * from '@gaddario98/react-pages';
-export * from '@gaddario98/react-form';
-export * from '@gaddario98/react-localization';
-export * from '@gaddario98/react-providers';
-export * from '@gaddario98/react-queries';
-export * from '@gaddario98/react-state';
-export * from '@gaddario98/utiles';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _gaddario98_react_form from '@gaddario98/react-form';
+import { FieldValues as FieldValues$1, FormManagerConfig as FormManagerConfig$1, Submit as Submit$1, SetValueFunction as SetValueFunction$1, FormManager as FormManager$1, SubmitKeysArg as SubmitKeysArg$1, FormElements as FormElements$1 } from '@gaddario98/react-form';
+import { QueriesArray as QueriesArray$1, MultipleQueryResponse as MultipleQueryResponse$1, AllMutation as AllMutation$1, QueryDefinition as QueryDefinition$1, MutationConfig as MutationConfig$1, QueryProps as QueryProps$1, QueryAtIndex as QueryAtIndex$1, ExtractQuery as ExtractQuery$1 } from '@gaddario98/react-queries';
+import * as _tanstack_react_form from '@tanstack/react-form';
+import { DeepKeys, DeepValue, FormOptions, FieldApi, FieldState, ReactFormExtendedApi } from '@tanstack/react-form';
+import * as React$1 from 'react';
+import React__default, { ComponentProps, PropsWithChildren, JSX as JSX$1, ReactNode } from 'react';
+import * as _gaddario98_react_state from '@gaddario98/react-state';
+import * as jotai_family from 'jotai-family';
+import * as jotai from 'jotai';
+import { PrimitiveAtom } from 'jotai';
+export { PrimitiveAtom } from 'jotai';
+import * as jotai_utils from 'jotai/utils';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, useQuery, UseMutationOptions, MutateOptions, useMutation, UseMutationResult, QueryClient } from '@tanstack/react-query';
+import { NotificationConfig } from '@gaddario98/react-notifications';
+import { AxiosRequestConfig } from 'axios';
+import { PersistQueryClientOptions } from '@tanstack/react-query-persist-client';
+import { ClassValue } from 'clsx';
+
+/**
+ * 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> = 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    /** 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    /** 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    /** 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    /** 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1>(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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> {
+    children?: Array<React.JSX.Element>;
+    allContents: Array<ContentItem<F, Q, V> | FormManagerConfig$1<F> | Submit$1<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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps<F, Q, V>, 'viewSettings'> & ViewSettings['header']) => React.ReactNode;
+    FooterContainer: <F extends FieldValues$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>>(props: Omit<DefaultContainerProps<F, Q, V>, 'viewSettings'> & ViewSettings['footer']) => React.ReactNode;
+    BodyContainer: <F extends FieldValues$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1<T> = Extract<keyof T, string>;
+type VariableTopKey<V> = StringKey$1<V>;
+type VariableValue<V, K extends VariableTopKey<V>> = V[K];
+type QueryTopKey$1<Q extends QueriesArray$1> = StringKey$1<MultipleQueryResponse$1<Q>>;
+type QuerySubKey$1<Q extends QueriesArray$1, K extends QueryTopKey$1<Q>> = StringKey$1<MultipleQueryResponse$1<Q>[K]>;
+type QueryCompositeKey$1<Q extends QueriesArray$1> = {
+    [K in QueryTopKey$1<Q>]: K | `${K}.${QuerySubKey$1<Q, K>}`;
+}[QueryTopKey$1<Q>];
+type QueryValue$1<Q extends QueriesArray$1, K extends QueryCompositeKey$1<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends QueryTopKey$1<Q> ? Sub extends QuerySubKey$1<Q, Top> ? MultipleQueryResponse$1<Q>[Top][Sub] : never : never : K extends QueryTopKey$1<Q> ? MultipleQueryResponse$1<Q>[K] : never;
+type MutationTopKey$1<Q extends QueriesArray$1> = StringKey$1<AllMutation$1<Q>>;
+type MutationSubKey$1<Q extends QueriesArray$1, K extends MutationTopKey$1<Q>> = StringKey$1<AllMutation$1<Q>[K]>;
+type MutationCompositeKey$1<Q extends QueriesArray$1> = {
+    [K in MutationTopKey$1<Q>]: K | `${K}.${MutationSubKey$1<Q, K>}`;
+}[MutationTopKey$1<Q>];
+type MutationValue$1<Q extends QueriesArray$1, K extends MutationCompositeKey$1<Q>> = K extends `${infer Top}.${infer Sub}` ? Top extends MutationTopKey$1<Q> ? Sub extends MutationSubKey$1<Q, Top> ? AllMutation$1<Q>[Top][Sub] : never : never : K extends MutationTopKey$1<Q> ? AllMutation$1<Q>[K] : never;
+type GetFunction<F extends FieldValues$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = {
+    <K extends QueryTopKey$1<Q>>(type: 'query', key: K): MultipleQueryResponse$1<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$1<Q>[K]['data']): MultipleQueryResponse$1<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$1<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$1<Q>[K]['data']): AllMutation$1<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<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$1, V extends Record<string, unknown> = Record<string, unknown>> = {
+    (type: 'form'): SetValueFunction$1<F>;
+    (type: 'state'): <K extends VariableTopKey<V>>(key: K, value: VariableValue<V, K>) => void;
+};
+type FunctionProps<F extends FieldValues$1, Q extends QueriesArray$1, 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$1, Q extends QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1, Q extends QueriesArray$1, 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$1, Q extends QueriesArray$1, 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$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = Items<F, Q, V> | ContainerItem<F, Q, V>;
+type MappedContents<F extends FieldValues$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = MappedItemsFunction<F, Q, Array<ContentItem<F, Q, V>>, V>;
+type ContentItemsType<F extends FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = Array<ContentItem<F, Q, V>> | MappedContents<F, Q, V>;
+type FormPageProps<F extends FieldValues$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = Omit<ComponentProps<typeof FormManager$1<F>>, 'updateFormValues' | 'submit' | 'data'> & {
+    defaultValueQueryKey?: Array<string>;
+    defaultValueQueryMap?: (props: ExtractQuery$1<Q>['response']) => DeepValue<F, DeepKeys<F>>;
+    submit?: Array<Submit$1<F>> | MappedItemsFunction<F, Q, Array<Submit$1<F>>, V>;
+    index?: number;
+    data?: Array<FormManagerConfig$1<F> | MappedItemsFunction<F, Q, FormManagerConfig$1<F>, V>>;
+    debounceDelay?: number;
+    hidden?: boolean | MappedItemsFunction<F, Q, boolean, V>;
+};
+type SingleQueryConfig$1<F extends FieldValues$1, Q extends QueryDefinition$1<any, any, any, any, any>, V extends Record<string, unknown> = Record<string, unknown>> = Q extends QueryDefinition$1<infer K, infer T, infer P, infer R, infer C> ? T extends 'mutation' ? {
+    type: 'mutation';
+    mutationConfig: (<Qa extends QueriesArray$1>(props: FunctionProps<F, Qa, V>) => MutationConfig$1<P, R, C>) | MutationConfig$1<P, R, C>;
+    key: K;
+} : {
+    type: 'query';
+    queryConfig?: (<Qa extends QueriesArray$1>(props: FunctionProps<F, Qa, V>) => Omit<QueryProps$1<K, R>, 'keyToMap'>) | Omit<QueryProps$1<K, R>, 'keyToMap'>;
+    key: K;
+} : never;
+type QueryPageConfigArray<F extends FieldValues$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> = {
+    [I in keyof Q]: SingleQueryConfig$1<F, QueryAtIndex$1<Q, I>, V>;
+};
+interface PageProps<F extends FieldValues$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>>(props: RenderComponentsProps<F, Q, V>) => react_jsx_runtime.JSX.Element;
+
+interface Props<F extends FieldValues$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> {
+    content: ContentItem<F, Q, V>;
+    ns: string;
+    pageId: string;
+}
+interface ContentProps<F extends FieldValues$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> extends Omit<Props<F, Q, V>, 'content'> {
+    content: ContainerItem<F, Q, V>;
+}
+
+declare const usePageConfig: <F extends FieldValues$1, Q extends QueriesArray$1, 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$1, QueriesArray$1> | undefined;
+    globalConfig: PageConfigProps;
+};
+
+interface GenerateContentProps<F extends FieldValues$1, Q extends QueriesArray$1, 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$1, Q extends QueriesArray$1, 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<F, Q, V> | _gaddario98_react_form.Submit<F, _gaddario98_react_form.SubmitKeysArg<F>> | _gaddario98_react_form.FormManagerConfig<F>)[];
+};
+
+interface GenerateContentRenderProps<F extends FieldValues$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>> {
+    contents?: ContentItemsType<F, Q, V>;
+    ns?: string;
+    pageId: string;
+    formData: {
+        formContents: Array<Submit$1<F, SubmitKeysArg$1<F>> | FormManagerConfig$1<F>>;
+        elements: Array<FormElements$1>;
+        errors: Array<unknown>;
+        formValues: F;
+        setValue: SetValueFunction$1<F>;
+    };
+}
+interface Elements {
+    index: number;
+    element: JSX.Element;
+    renderInFooter: boolean;
+    renderInHeader: boolean;
+    key: string;
+}
+declare const useGenerateContentRender: <F extends FieldValues$1, Q extends QueriesArray$1, 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$1<F, SubmitKeysArg$1<F>> | FormManagerConfig$1<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$1, Q extends QueriesArray$1, 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$1, Q extends QueriesArray$1, V extends Record<string, unknown> = Record<string, unknown>>({ form, pageId }: {
+    form?: FormPageProps<F, Q, V>;
+    pageId: string;
+}): {
+    mappedFormData: FormManagerConfig$1<F>[];
+    formSubmit: Submit$1<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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1> {
+    /** 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$1 = FieldValues$1, Q extends QueriesArray$1 = QueriesArray$1>({ 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;
+
+interface FormNotificationMessage {
+    message: string;
+    type: 'success' | 'error' | 'info' | 'warning';
+    autoHideDuration?: number;
+    textTransOption?: Record<string, unknown>;
+    ns?: string;
+}
+interface FormTranslationOptions {
+    [key: string]: string | number | boolean | undefined;
+    ns?: string;
+}
+interface FormConfigProps {
+    formFieldContainer: React.FC<PropsWithChildren>;
+    showNotification?: (notification: FormNotificationMessage) => void;
+    translateText?: (key: string, options?: FormTranslationOptions) => string;
+}
+declare const formConfigAtom: _gaddario98_react_state.PrimitiveAtom<FormConfigProps>;
+declare const useFormConfigValue: () => FormConfigProps;
+declare const useFormConfigState: () => [FormConfigProps, (value: FormConfigProps) => void];
+declare const useFormConfigReset: () => () => void;
+
+interface UseCustomFormOptions<TData extends FieldValues> extends FormOptions<TData, any, any, any, any, any, any, any, any, any, any, any> {
+    formId?: string;
+}
+declare function useJotaiForm<TData extends FieldValues>(formOptions: UseCustomFormOptions<TData>): _tanstack_react_form.ReactFormExtendedApi<TData, any, any, any, any, any, any, any, any, any, any, any>;
+
+interface FormElements {
+    index: number;
+    element: JSX$1.Element;
+    renderInFooter: boolean;
+    renderInHeader: boolean;
+    isSubmit?: boolean;
+}
+declare const useFormManager: <F extends FieldValues = FieldValues>({ data, onInvalid, submit, notification, formOptions, onValuesChange, globalErrorNs, id, }: UseFormManagerProps<F>) => {
+    elements: FormElements[];
+    formContents: (FormManagerConfig<F> | ((props: FormFunctionProps<F>) => FormManagerConfig<F>) | Submit<F, SubmitKeysArg<F>>)[];
+    errors: any[];
+    formValues: F;
+    setValue: SetValueFunction<F>;
+};
+
+interface UseFormValuesProps {
+    formId: string;
+    scopeId?: string;
+}
+declare const useFormValues: <F extends FieldValues>({ formId, }: UseFormValuesProps) => FormFunctionProps<F>;
+
+type FieldValues = Record<string, any>;
+type SetValueFunction<F extends FieldValues> = <TField extends DeepKeys<F>>(field: TField, value: DeepValue<F, TField>) => void;
+type GetFormValuesFunction<F extends FieldValues> = {
+    <TField extends DeepKeys<F>>(key: TField): DeepValue<F, TField> | undefined;
+    <TField extends DeepKeys<F>>(key: TField, defaultValue: DeepValue<F, TField>): NonNullable<DeepValue<F, TField>>;
+};
+type GenericFormApi<TData extends FieldValues> = ReactFormExtendedApi<TData, any, any, any, any, any, any, any, any, any, any, any>;
+type GenericFieldApi<TData extends FieldValues> = FieldApi<TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type GenericFieldState<TData extends FieldValues> = FieldState<TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type SubmitKeysArg<T> = ReadonlyArray<keyof T> | undefined;
+type SubmitPayload<T, K extends SubmitKeysArg<T>> = K extends ReadonlyArray<keyof T> ? Pick<T, K[number]> : T;
+type FormFunctionProps<F extends FieldValues> = {
+    get: GetFormValuesFunction<F>;
+    set: SetValueFunction<F>;
+};
+interface Submit<T extends FieldValues = FieldValues, K extends SubmitKeysArg<T> = SubmitKeysArg<T>> {
+    onSuccess?: (values: T) => void;
+    onError?: (err: Error) => void;
+    values?: K;
+    index?: number;
+    buttonProps?: Record<string, unknown>;
+    renderInFooter?: boolean;
+    hidden?: boolean;
+    renderInHeader?: boolean;
+    isDisabled?: boolean;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    isLoading?: boolean;
+    usedBoxes?: number;
+    type?: 'submit' | 'button';
+    key?: string;
+    component?: (props: {
+        onClick: () => void;
+        index: number;
+        key: string;
+        type: 'submit' | 'button';
+    }) => React__default.JSX.Element;
+}
+interface ViewSettingsContainerProps {
+    children: React__default.ReactNode;
+}
+type FormManagerProps<T extends FieldValues = FieldValues> = {
+    data: Array<FormManagerConfig<T> | ((props: FormFunctionProps<T>) => FormManagerConfig<T>)>;
+    defaultValues: T;
+    onInvalid?: (err: unknown) => void;
+    isHiddenErrors?: boolean;
+    ns?: string;
+    globalErrorNs?: string;
+    submit?: Array<Submit<T>>;
+    notification?: {
+        success?: FormNotificationMessage | ((res: unknown) => FormNotificationMessage);
+        error?: FormNotificationMessage | ((error: string) => FormNotificationMessage);
+        ns?: string;
+    };
+    onValuesChange?: (props: T, setValue: (name: any, value: any) => void) => void;
+    formSettings?: UseCustomFormOptions<T>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    id?: string;
+    viewSettings?: {
+        container?: React__default.ComponentType<ViewSettingsContainerProps>;
+        submitContainer?: React__default.ComponentType<ViewSettingsContainerProps>;
+        bodyContainer?: React__default.ComponentType<ViewSettingsContainerProps>;
+        containerProps?: Record<string, unknown>;
+        submitContainerProps?: Record<string, unknown>;
+        bodyContainerProps?: Record<string, unknown>;
+    };
+};
+type UseFormManagerProps<T extends FieldValues> = {
+    data: Array<FormManagerConfig<T> | ((props: FormFunctionProps<T>) => FormManagerConfig<T>)>;
+    onInvalid?: (err: unknown) => void;
+    formOptions: UseCustomFormOptions<T>;
+    isHiddenErrors?: boolean;
+    ns?: string;
+    globalErrorNs?: string;
+    submit?: Array<Submit<T>>;
+    notification?: {
+        success?: FormNotificationMessage | ((res: unknown) => FormNotificationMessage);
+        error?: FormNotificationMessage | ((error: string) => FormNotificationMessage);
+        ns?: string;
+    };
+    onValuesChange?: (props: T, setValue: (name: any, value: any) => void) => void;
+    id?: string;
+};
+interface FieldComponentProps<T extends FieldValues> {
+    value: any;
+    onChange: (value: any) => void;
+    onBlur: () => void;
+    error?: boolean;
+    errorMessage?: string;
+    formValues?: T;
+    label?: string;
+    helperMessage?: string;
+}
+type FormManagerConfig<T extends FieldValues> = Omit<FormFieldConfig<T>, 'field' | 'fieldState' | 'fieldValues'>;
+type MappedFormItemsFunction<F extends FieldValues, ComponentType> = (props: FormFunctionProps<F>) => ComponentType;
+type Rules = {
+    validate?: (value: any) => string | undefined | Promise<string | undefined>;
+    onChange?: (value: any) => void;
+    onBlur?: () => void;
+    onMount?: (value: any) => void;
+};
+type FormFieldConfig<T extends FieldValues> = {
+    name: any;
+    label?: string;
+    rules?: Rules | MappedFormItemsFunction<T, Rules>;
+    field: GenericFieldApi<T>;
+    fieldState: GenericFieldState<T>;
+    containerStyle?: string;
+    component: (props: Omit<FieldComponentProps<T>, 'formValues'>) => React__default.JSX.Element;
+    container?: React__default.FC<PropsWithChildren>;
+    ns?: string;
+    errorNs?: string;
+    index?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    usedBoxes?: number;
+    key?: string;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    helper?: {
+        text?: string;
+        translationOption?: FormTranslationOptions;
+    };
+    onFieldChange?: (value: any) => void;
+    hidden?: boolean | MappedFormItemsFunction<T, boolean>;
+};
+interface ErrorComponentProps {
+    message?: string;
+    fieldName?: string;
+}
+interface FormContainerProps {
+    className?: string;
+    children: React__default.ReactNode;
+}
+interface FormFieldProps<T extends FieldValues> {
+    config: FormFieldConfig<T>;
+    onFieldChange?: (value: T) => void;
+    ns?: string;
+    globalErrorNs?: string;
+    container?: React__default.FC<PropsWithChildren>;
+}
+
+interface DefaultFormContainerProps {
+    children: React.ReactNode;
+}
+declare let DefaultContainer: ({ children }: ViewSettingsContainerProps) => React$1.ReactNode;
+declare const setDefaultFormContainer: (val: ({ children, }: ViewSettingsContainerProps) => React.ReactNode) => void;
+declare const DefaultFormContainer: <_T extends FieldValues = FieldValues>({ children, }: ViewSettingsContainerProps) => react_jsx_runtime.JSX.Element;
+
+declare const FormManager: <T extends Record<string, any> = FieldValues>({ data, defaultValues, onInvalid, submit, ns, globalErrorNs, notification, formSettings, viewSettings, onValuesChange, id, }: FormManagerProps<T>) => react_jsx_runtime.JSX.Element;
+
+declare const FormField: <T extends FieldValues>({ config, onFieldChange, ns: globalNs, globalErrorNs, }: FormFieldProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FormStoreEntry<F extends FieldValues = FieldValues> {
+    formValues: F;
+    setValue: SetValueFunction<F>;
+}
+declare const DEFAULT_FORM_ENTRY: FormStoreEntry<FieldValues>;
+/**
+ * Global atom storing all form state.
+ * Key format: "scopeId:formId" or just "formId" for backward compatibility.
+ */
+declare const formAtom: jotai.PrimitiveAtom<Record<string, FormStoreEntry<FieldValues>>> & {
+    init: Record<string, FormStoreEntry<FieldValues>>;
+};
+/**
+ * Helper to generate composite keys for forms.
+ */
+declare const getFormCompositeKey: (scopeId: string, key: string) => string;
+/**
+ * Creates a derived atom for accessing forms of a specific scope.
+ */
+declare const createScopeFormsAtom: (scopeId: string) => jotai.WritableAtom<Record<string, FormStoreEntry<FieldValues>>, [update: Record<string, FormStoreEntry<FieldValues>>], void>;
+declare const createFormSelector: <F extends FieldValues = FieldValues>(formId: string) => jotai.Atom<FormStoreEntry<F>>;
+declare const useFormValue: <F extends FieldValues>(formId: string) => FormStoreEntry<F>;
+declare const useFormState: <F extends FieldValues>() => [Record<string, FormStoreEntry<F>>, (value: Record<string, FormStoreEntry<F>>) => void];
+declare const useSetFormState: <F extends FieldValues>(formId: string) => (val: Partial<FormStoreEntry<F>>) => void;
+
+type Locale = string;
+type TranslationResources = Record<string, any>;
+/**
+ * Opzioni di formattazione per i diversi tipi di valori
+ */
+interface FormatOptions {
+    number?: Intl.NumberFormatOptions;
+    date?: Intl.DateTimeFormatOptions;
+    currency?: Intl.NumberFormatOptions & {
+        currency?: string;
+    };
+}
+/**
+ * Opzioni per la traduzione con supporto parametri avanzati
+ */
+interface TranslationOptions {
+    [key: string]: any;
+    defaultValue?: string;
+    /**
+     * Opzioni di formattazione per i parametri specifici
+     *
+     * @example
+     * ```ts
+     * t('welcome', {
+     *   price: 1234.56,
+     *   formatOptions: {
+     *     price: {
+     *       currency: { currency: 'EUR', minimumFractionDigits: 2 }
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    formatOptions?: Record<string, FormatOptions>;
+    ns?: string;
+}
+/**
+ * Funzione di traduzione con supporto parametri avanzati
+ *
+ * @example Interpolazione semplice
+ * ```ts
+ * t('welcome', { name: 'Mario' })
+ * // "Benvenuto {{name}}" -> "Benvenuto Mario"
+ * ```
+ *
+ * @example Formattazione numeri
+ * ```ts
+ * t('items_count', { count: 1000 })
+ * // "Hai {{count, number}} elementi" -> "Hai 1,000 elementi"
+ * ```
+ *
+ * @example Formattazione date
+ * ```ts
+ * t('last_login', { date: new Date() })
+ * // "Ultimo accesso: {{date, date}}" -> "Ultimo accesso: 15/12/2025"
+ * ```
+ *
+ * @example Formattazione valuta
+ * ```ts
+ * t('total', {
+ *   price: 99.99,
+ *   formatOptions: {
+ *     price: { currency: { currency: 'EUR' } }
+ *   }
+ * })
+ * // "Totale: {{price, currency}}" -> "Totale: €99.99"
+ * ```
+ *
+ * @example Pluralizzazione
+ * ```ts
+ * t('items', { count: 0 })
+ * // "{{count, plural, =0{Nessun elemento} one{Un elemento} other{# elementi}}}"
+ * // -> "Nessun elemento"
+ *
+ * t('items', { count: 1 })
+ * // -> "Un elemento"
+ *
+ * t('items', { count: 5 })
+ * // -> "5 elementi"
+ * ```
+ *
+ * @example Selezione
+ * ```ts
+ * t('greeting', { gender: 'male' })
+ * // "{{gender, select, male{Benvenuto} female{Benvenuta} other{Benvenuto/a}}}"
+ * // -> "Benvenuto"
+ * ```
+ */
+type TranslateFunction = (key: string, options?: TranslationOptions) => string;
+interface I18nConfig {
+    defaultLocale: Locale;
+    supportedLocales: Array<Locale>;
+}
+
+interface LocalizationConfigProps {
+    currentLocale: Locale;
+    locales: Record<Locale, TranslationResources>;
+}
+declare const localizationConfigAtom: _gaddario98_react_state.PrimitiveAtom<LocalizationConfigProps>;
+declare const useLocalizationConfigValue: () => LocalizationConfigProps;
+declare const useLocalizationConfigState: () => [LocalizationConfigProps, (value: LocalizationConfigProps) => void];
+declare const useLocalizationConfigReset: () => () => void;
+/**
+ * Hook per gestire le operazioni di localization
+ */
+declare const useLocalizationActions: () => {
+    /**
+     * Aggiunge o aggiorna una locale con le sue risorse
+     */
+    addLocale: (locale: Locale, resources: TranslationResources) => void;
+    /**
+     * Switch alla locale specificata
+     */
+    switchLocale: (locale: Locale) => void;
+    /**
+     * Inizializza con una locale di default
+     */
+    initializeLocale: (locale: Locale, resources: TranslationResources) => void;
+};
+
+/**
+ * Funzione core per risolvere una traduzione.
+ */
+declare const resolveTranslation: (key: string, resources: TranslationResources, options?: TranslationOptions, locale?: string) => string;
+
+declare const useTranslation: (_ns?: string) => {
+    t: TranslateFunction;
+    locale: Locale;
+};
+
+/**
+ * Crea un'istanza di traduzione per l'uso lato server (o fuori dai componenti React).
+ */
+declare const createServerTranslator: (resources: TranslationResources, locale?: Locale) => {
+    t: TranslateFunction;
+    locale: Locale;
+};
+
+type TranslationFunction = (key: string, options?: TranslationOptions) => string;
+/**
+ * Hook per tradurre testi che si adatta al sistema di traduzione interno.
+ * Wrapper di retro-compatibilità per useTranslation.
+ *
+ * @param ns - Namespace opzionale (ignorato nella nuova implementazione)
+ * @returns Un oggetto con la funzione traslateText (e alias t)
+ */
+declare const useTranslatedText: (ns?: string) => {
+    traslateText: (text: string, options?: TranslationOptions) => string;
+    t: (text: string, options?: TranslationOptions) => string;
+};
+
+type ProviderConfig = React__default.ComponentType<{
+    children: ReactNode;
+}> | [React__default.ComponentType<any>, any];
+interface AppProvidersProps {
+    providers?: Array<ProviderConfig>;
+}
+declare const AppProviders: React__default.FC<PropsWithChildren<AppProvidersProps>>;
+
+type ApiMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type Endpoint = Record<string, string>;
+interface QueriesProps<TProps, TResponse, TConverter = null> {
+    endpoint: [keyof Endpoint, string] | [keyof Endpoint];
+    queryKeyToInvalidate?: Array<string>;
+    headers?: AxiosRequestConfig['headers'];
+    method: ApiMethod;
+    converter?: (props: TProps) => TConverter;
+    customRequest?: (url: string, method: string, data: TProps) => Promise<TResponse>;
+    mutateOptions?: MutateOptions<TResponse, Error, TProps, unknown>;
+    isTest?: boolean;
+    notification?: {
+        success?: NotificationConfig | ((res: TResponse) => NotificationConfig);
+        error?: NotificationConfig | ((error: string) => NotificationConfig);
+        translationOption?: Record<string, any>;
+    };
+}
+interface QueryProps<Key extends string, TResponse> {
+    endpoint: [keyof Endpoint, string] | [keyof Endpoint];
+    queryKey: Array<string>;
+    enabled: boolean;
+    keyToMap: Key;
+    disableLoading?: boolean;
+    customQueryFn?: () => Promise<TResponse>;
+    headers?: AxiosRequestConfig['headers'];
+    disableAuthControl?: boolean;
+    onDataChanged?: (data: TResponse) => void;
+    onStateChange?: (state: QueryResult<TResponse>) => void;
+    options?: Omit<Parameters<typeof useQuery<TResponse>>['0'], 'queryKey' | 'queryFn'>;
+}
+interface CustomQueryOptions<TResponse> extends Omit<UseQueryOptions<TResponse, Error>, 'queryKey' | 'queryFn'> {
+    endpoint: [keyof Endpoint, string] | [keyof Endpoint];
+    queryKey: Array<string>;
+    headers?: AxiosRequestConfig['headers'];
+    disableAuthControl?: boolean;
+    onDataChanged?: (data: TResponse | undefined) => void;
+    onStateChange?: (state: QueryResult<TResponse>) => void;
+    options?: Omit<Parameters<typeof useQuery<TResponse>>['0'], 'queryKey' | 'queryFn'>;
+    keyToMap?: string;
+    disableLoading?: boolean;
+    customQueryFn?: () => Promise<TResponse>;
+}
+interface CustomMutationOptions<TProps, TResponse> extends UseMutationOptions<TResponse, Error, TProps, unknown> {
+    endpoint: [keyof Endpoint, string] | [keyof Endpoint];
+    method: ApiMethod;
+    headers?: AxiosRequestConfig['headers'];
+    queryKeyToInvalidate?: Array<string>;
+    customRequest?: (url: string, method: string, data: TProps) => Promise<TResponse>;
+    converter?: (props: TProps) => any;
+    isTest?: boolean;
+    notification?: {
+        success?: NotificationConfig | ((res: TResponse) => NotificationConfig);
+        error?: NotificationConfig | ((error: string) => NotificationConfig);
+        translationOption?: Record<string, any>;
+    };
+}
+type QueryDefinition<K extends string, T extends 'query' | 'mutation' | 'websocket', P, R, C = any> = {
+    key: K;
+    props: P;
+    response?: R;
+    converter: C;
+    type: T;
+};
+type QueriesArray = Array<QueryDefinition<string, any, any, any, any>>;
+type ExtractQuery<Q extends QueriesArray> = Extract<Q[number], {
+    type: 'query';
+}>;
+type ExtractWebSocket<Q extends QueriesArray> = Extract<Q[number], {
+    type: 'websocket';
+}>;
+type ExtractQueryResponse<Q extends QueriesArray, K extends Q[number]['key']> = Extract<Q[number], {
+    key: K;
+}>;
+type ExtractMutation<Q extends QueriesArray> = Extract<Q[number], {
+    type: 'mutation';
+}>;
+type CustomMutation<TData = unknown, TError = Error, TVariables = void, TOnMutateResult = unknown> = typeof useMutation<TData, TError, TVariables, TOnMutateResult> & {
+    endpoint: string;
+};
+type AllMutation<Q extends QueriesArray = QueriesArray> = {
+    [K in ExtractMutation<Q>['key']]: ReturnType<CustomMutation<ExtractQueryResponse<Q, K>['response'], Error, ExtractQueryResponse<Q, K>['props'], unknown>> & {
+        endpoint: QueriesProps<any, any>['endpoint'];
+    };
+};
+type ExtractMutationByKey<Q extends QueriesArray = QueriesArray, K extends ExtractMutation<Q>['key'] = ExtractMutation<Q>['key']> = ReturnType<CustomMutation<ExtractQueryResponse<Q, K>['response'], Error, ExtractQueryResponse<Q, K>['props'], unknown>>;
+type ExtractQueryByKey<Q extends QueriesArray = QueriesArray, K extends ExtractQuery<Q>['key'] = ExtractQuery<Q>['key']> = {
+    data?: ExtractQueryResponse<Q, K>['response'];
+    isLoading: boolean;
+    isLoadingMapped: boolean;
+    isFetching: boolean;
+    isPending: boolean;
+    error: Error | null;
+    refetch: () => Promise<unknown>;
+};
+interface MutationConfig<TProps = unknown, TResponse = unknown, TConverter = any> extends QueriesProps<TProps, TResponse, TConverter> {
+    method: 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    onStateChange?: (state: MutationStateInternal<TResponse>) => void;
+}
+interface QueryResult<TResponse> {
+    data?: TResponse;
+    isLoading: boolean;
+    isLoadingMapped: boolean;
+    isFetching: boolean;
+    isPending: boolean;
+    error: Error | null;
+    refetch: () => Promise<unknown>;
+}
+type MultipleQueryResponse<Q extends QueriesArray> = {
+    [K in ExtractQuery<Q>['key']]: {
+        data: ExtractQueryResponse<Q, K>['response'];
+        isLoading: boolean;
+        isLoadingMapped: boolean;
+        isFetching: boolean;
+        isPending: boolean;
+        error: Error | null;
+        refetch: () => Promise<unknown>;
+    };
+};
+interface QueryConfig<K extends string, TResponse> extends CustomQueryOptions<TResponse> {
+    keyToMap: K;
+}
+type SingleQueryConfig<Q extends QueryDefinition<any, any, any, any>> = Q extends QueryDefinition<infer K, infer T, infer P, infer R, infer C> ? T extends 'mutation' ? {
+    type: 'mutation';
+    mutationConfig: MutationConfig<P, R, C>;
+    key: K;
+} : T extends 'query' ? {
+    type: 'query';
+    queryConfig?: Omit<QueryConfig<K, R>, 'keyToMap'>;
+    key: K;
+} : WebSocketDefinition<K> : never;
+type QueryAtIndex<Q extends QueriesArray, I extends keyof Q> = Q[I] extends QueryDefinition<infer K, infer T, infer P, infer R, infer C> ? QueryDefinition<K, T, P, R, C> : never;
+type QueryConfigArray<Q extends QueriesArray> = {
+    [I in keyof Q]: SingleQueryConfig<QueryAtIndex<Q, I>>;
+};
+interface ContextValue<Q extends QueriesArray> {
+    allMutation: AllMutation<Q>;
+    allQuery: MultipleQueryResponse<Q>;
+    allWebSocket: MultipleWebSocketResponse<Q[number]['key']>;
+    refreshQueries: () => void;
+}
+type MultipleWebSocketResponse<K extends string = string> = {
+    [key in K]: WebSocketResult;
+};
+type MutationItem<Q extends QueriesArray> = Extract<QueryConfigArray<Q>[number], {
+    type: 'mutation';
+    mutationConfig: any;
+}>;
+type QueryItem<Q extends QueriesArray> = Extract<QueryConfigArray<Q>[number], {
+    type: 'query';
+}>;
+interface WebSocketDefinition<TKey extends string = string> {
+    key: TKey;
+    endpoint?: string;
+    onMessage?: (data: any) => void;
+    invalidateQueriesOnMessage?: Array<string>;
+    autoConnect?: boolean;
+    type: 'websocket';
+}
+type WebSocketsArray = Array<WebSocketDefinition<string>>;
+interface WebSocketResult {
+    lastMessage: any;
+    sendMessage: (message: any) => void;
+    status: 'connecting' | 'open' | 'closed';
+}
+interface MutationStateInternal<TData = unknown> {
+    status: 'idle' | 'pending' | 'success' | 'error';
+    data: TData | undefined;
+    error: Error | null;
+    submittedAt: number | null;
+    variables: unknown | undefined;
+}
+type MutationActionInternal = {
+    type: 'RESET';
+    key: string;
+} | {
+    type: 'PENDING';
+    key: string;
+    submittedAt: number;
+    variables: unknown;
+} | {
+    type: 'SUCCESS';
+    key: string;
+    data: unknown;
+} | {
+    type: 'ERROR';
+    key: string;
+    error: Error;
+};
+type StringKey<T> = Extract<keyof T, string>;
+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 GetApiValuesFunction<Q extends QueriesArray> = {
+    <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 MutationCompositeKey<Q>>(type: 'mutation', key: K, defaultValue: unknown): NonNullable<MutationValue<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 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>>;
+    (type: 'query' | 'mutation', key: string, defaultValue?: unknown): unknown;
+};
+
+type QueryStoreEntry<Q extends QueriesArray = QueriesArray> = QueryResult<Q[number]['response']>;
+type MutationStoreEntry<Q extends QueriesArray = QueriesArray> = UseMutationResult<Q[number]['response'], Error, Q[number]['props'], unknown>;
+declare const DEFAULT_QUERY_ENTRY: QueryStoreEntry;
+declare const DEFAULT_MUTATION_ENTRY: MutationStoreEntry;
+/**
+ * Global atom storing all query results.
+ * Key format: "scopeId:queryKey"
+ */
+declare const queriesAtom: jotai.WritableAtom<Record<string, QueryStoreEntry<QueriesArray>>, [Record<string, QueryStoreEntry<QueriesArray>> | typeof jotai_utils.RESET | ((prev: Record<string, QueryStoreEntry<QueriesArray>>) => Record<string, QueryStoreEntry<QueriesArray>> | typeof jotai_utils.RESET)], void>;
+/**
+ * Global atom storing all mutation results.
+ * Key format: "scopeId:mutationKey"
+ */
+declare const mutationsAtom: jotai.PrimitiveAtom<Record<string, MutationStoreEntry<QueriesArray>>> & {
+    init: Record<string, MutationStoreEntry<QueriesArray>>;
+};
+declare const getCompositeKey: (scopeId: string, key: string) => string;
+/**
+ * Creates a derived atom for accessing queries of a specific scope.
+ */
+declare const createScopeQueriesAtom: (scopeId: string) => jotai.WritableAtom<Record<string, QueryStoreEntry<QueriesArray>>, [update: Record<string, QueryStoreEntry<QueriesArray>>], void>;
+/**
+ * Creates a derived atom for accessing mutations of a specific scope.
+ */
+declare const createScopeMutationsAtom: (scopeId: string) => jotai.WritableAtom<Record<string, MutationStoreEntry<QueriesArray>>, [update: Record<string, MutationStoreEntry<QueriesArray>>], void>;
+declare const createQuerySelector: <Q extends QueriesArray>(scopeId: string, queryKey: string) => jotai.Atom<QueryStoreEntry<Q>>;
+declare const createMutationSelector: <Q extends QueriesArray>(scopeId: string, mutationKey: string) => jotai.Atom<MutationStoreEntry<Q>>;
+
+interface EncryptionConfig {
+    secretKey: string;
+    enabled?: boolean;
+    encryptFn?: (data: unknown, key: string) => Promise<string>;
+    decryptFn?: (data: string, key: string) => Promise<unknown>;
+}
+type ApiConverter<TProps, TConverter> = (props: TProps) => TConverter;
+interface ApiRequestFnProps<TProps, TConverter = TProps> {
+    url: string;
+    method: ApiMethod;
+    body?: TProps;
+    headers?: AxiosRequestConfig['headers'];
+    converter?: ApiConverter<TProps, TConverter>;
+}
+interface ApiNotificationMessage {
+    message: string;
+    type: 'success' | 'error' | 'info' | 'warning';
+    autoHideDuration?: number;
+    textTransOption?: Record<string, unknown>;
+    ns?: string;
+}
+interface ApiConfig {
+    endpoints: Endpoint;
+    requestFn: <TProps, TResponse, TConverter = TProps>(props: ApiRequestFnProps<TProps, TConverter>) => Promise<TResponse>;
+    validateAuthFn?: () => boolean;
+    defaultHeaders?: Record<string, string>;
+    persistOptions?: Omit<PersistQueryClientOptions, 'queryClient'>;
+    queryClient: QueryClient;
+    websocketConfig?: {
+        url: string;
+        onMessage?: (message: unknown) => void;
+        autoConnect?: boolean;
+    };
+    encryption?: EncryptionConfig;
+    showNotification?: (notification: ApiNotificationMessage) => void;
+}
+declare const apiConfigAtom: _gaddario98_react_state.PrimitiveAtom<ApiConfig>;
+declare const useApiConfigValue: () => ApiConfig;
+declare const useApiConfigState: () => [ApiConfig, (value: ApiConfig) => void];
+declare const useApiConfigReset: () => () => void;
+
+declare const useQueryApi: <TResponse>(options: CustomQueryOptions<TResponse>, id?: string) => QueryResult<TResponse>;
+
+declare const useMutateApi: <TProps, TResponse>(options: CustomMutationOptions<TProps, TResponse>, id?: string) => _tanstack_react_query.UseMutationResult<TResponse, Error, TProps, unknown>;
+
+declare const useMultipleQuery: <Q extends QueriesArray>(settings?: Array<QueryProps<Q[number]["key"], Q[number]["response"]>>) => MultipleQueryResponse<Q>;
+
+declare const useMultipleMutation: <Q extends QueriesArray>(configs: Array<MutationItem<Q>>) => AllMutation<Q>;
+
+declare const useMultipleWebSocket: <K extends string>(configs?: Array<WebSocketDefinition<K>>) => MultipleWebSocketResponse<K>;
+
+interface UseApiOptions {
+    /**
+     * Unique identifier for this scope. Used as the key prefix for Jotai atoms.
+     * @default 'default'
+     */
+    scopeId?: string;
+    /**
+     * Whether to persist query/mutation results to Jotai atoms.
+     * @default true
+     */
+    persistToAtoms?: boolean;
+}
+/**
+ * Main hook that integrates TanStack Query with Jotai for state persistence.
+ */
+declare function useApi<Q extends QueriesArray>(configs: QueryConfigArray<Q>, options?: UseApiOptions): ContextValue<Q>;
+/**
+ * @deprecated Use options object instead: useApi(configs, { scopeId: 'my-scope' })
+ */
+declare function useApi<Q extends QueriesArray>(configs: QueryConfigArray<Q>, id?: string): ContextValue<Q>;
+
+declare const useWebSocket: (endpoint?: string, // specific socket endpoint if different from default
+options?: {
+    onMessage?: (data: unknown) => void;
+    invalidateQueriesOnMessage?: Array<string>;
+}) => WebSocketResult;
+
+declare const useInvalidateQueries: () => {
+    invalidateQueries: (queryKeys: Array<Array<string>>) => Promise<void>;
+};
+
+/**
+ * Hook to read all queries for a scope.
+ */
+declare function useJotaiQueries<Q extends QueriesArray>(options: {
+    scopeId: string;
+}): Record<string, QueryStoreEntry<Q>>;
+/**
+ * Hook to read all mutations for a scope.
+ */
+declare function useJotaiMutations<Q extends QueriesArray>(options: {
+    scopeId: string;
+}): Record<string, MutationStoreEntry<Q>>;
+
+interface UseApiValuesProps {
+    scopeId: string;
+}
+declare const useApiValues: <Q extends QueriesArray>({ scopeId, }: UseApiValuesProps) => {
+    get: GetApiValuesFunction<Q>;
+};
+
+declare const QueriesProvider: React.FC<PropsWithChildren>;
+
+declare const algorithm: {
+    name: string;
+    length: number;
+};
+declare const str2ab: (str: string) => ArrayBuffer;
+declare const ab2str: (buf: ArrayBuffer) => string;
+declare const importKey: (secretKey: string) => Promise<CryptoKey>;
+declare const encryptData: (data: any, secretKey: string) => Promise<string>;
+declare const decryptData: (encryptedData: string, secretKey: string) => Promise<any>;
+
+declare const apiRequest: <TProps, TResponse, TConverter = TProps>({ method, url, body, headers, converter, }: ApiRequestFnProps<TProps, TConverter>) => Promise<TResponse>;
+declare const fetchRequest: <TProps, TResponse>(url: string, headers?: AxiosRequestConfig["headers"]) => Promise<TResponse>;
+
+type SyncStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+declare let storage: SyncStorage;
+declare const setCustomStorage: (newStorage: SyncStorage) => void;
+
+type AtomGeneratorOptions<T> = {
+    key: string;
+    defaultValue: T;
+    persist?: boolean;
+    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+};
+type AtomState<T> = {
+    atom: PrimitiveAtom<T>;
+    useValue: () => T;
+    useState: () => [T, (value: T) => void];
+    useReset: () => () => void;
+};
+declare function atomStateGenerator<T>(options: AtomGeneratorOptions<T> & {
+    persist: true;
+}): AtomState<T>;
+declare function atomStateGenerator<T>(options: AtomGeneratorOptions<T> & {
+    persist?: false;
+}): AtomState<T>;
+
+declare function cn(...inputs: Array<ClassValue>): string;
+
+type ExtractorCache<T> = Map<string, T>;
+declare function createExtractor<T extends Record<string, unknown>, K extends keyof T = keyof T>(allData?: T, cache?: ExtractorCache<Partial<T>>, usedKeys?: Array<K>): T;
+
+type PropsAreEqual<P> = (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean;
+/**
+ * Wrapper per React.memo che preserva i tipi generici
+ */
+declare function withMemo<T extends React.ComponentType<any>>(Component: T, propsAreEqual?: PropsAreEqual<React.ComponentProps<T>>): T;
+
+export { AppProviders, DEFAULT_FORM_ENTRY, DEFAULT_MUTATION_ENTRY, DEFAULT_QUERY_ENTRY, DefaultContainer, DefaultFormContainer, FormField, FormManager, MemoizationCache, MetadataStoreProvider, PageGenerator, QueriesProvider, RenderComponents, ab2str, algorithm, apiConfigAtom, apiRequest, applyMetadataToDom, atomStateGenerator, buildArticleJsonLd, buildBreadcrumbListJsonLd, buildFAQPageJsonLd, buildOrganizationJsonLd, buildProductJsonLd, buildWebSiteJsonLd, clearMetadataLog, cn, collectMetadataToHtml, createExtractor, createFormSelector, createMetadataStore, createMutationSelector, createQuerySelector, createScopeFormsAtom, createScopeMutationsAtom, createScopePageVariablesAtom, createScopeQueriesAtom, createServerTranslator, decryptData, deepEqual, encryptData, fetchRequest, formAtom, formConfigAtom, generateLlmsFullTxt, generateLlmsTxt, generateRobotsTxt, generateSitemapEntries, generateSitemapXml, getCompositeKey, getFormCompositeKey, getMetadata, getMetadataLog, getPageConfig, getPageVariablesCompositeKey, importKey, isStableValue, localizationConfigAtom, logMetadata, memoPropsComparator, memoize, mutationsAtom, optimizeDeps, pageConfigAtom, pageToMarkdown, pageVariablesAtom, pageVariablesAtomFamily, queriesAtom, resetMetadata, resolveMetadata, resolveTranslation, setCustomStorage, setDefaultFormContainer, setMetadata, setMetadataLogging, shallowEqual, storage, str2ab, toNextHeadTags, toNextMetadata, useApi, useApiConfigReset, useApiConfigState, useApiConfigValue, useApiValues, useApplyMetadata, useFormConfigReset, useFormConfigState, useFormConfigValue, useFormData, useFormManager, useFormState, useFormValue, useFormValues, useGenerateContent, useGenerateContentRender, useInvalidateQueries, useJotaiForm, useJotaiMutations, useJotaiQueries, useLocalizationActions, useLocalizationConfigReset, useLocalizationConfigState, useLocalizationConfigValue, useMetadata, useMetadataStore, useMultipleMutation, useMultipleQuery, useMultipleWebSocket, useMutateApi, usePageConfig, usePageConfigReset, usePageConfigState, usePageConfigValue, useQueryApi, useSetFormState, useTranslatedText, useTranslation, useViewSettings, useWebSocket, withMemo };
+export type { AIHintsConfig, AllMutation, AlternatesConfig, ApiConfig, ApiConverter, ApiMethod, ApiNotificationMessage, ApiRequestFnProps, AppProvidersProps, ArticleJsonLdInput, AtomGeneratorOptions, AtomState, BreadcrumbItem, ContainerItem, ContentItem, ContentItemsType, ContentProps, ContextValue, CustomMutation, CustomMutationOptions, CustomQueryOptions, DefaultContainerProps, DefaultFormContainerProps, DependencyGraph, DependencyNode, Elements, EncryptionConfig, Endpoint, ErrorComponentProps, ExtractMutation, ExtractMutationByKey, ExtractQuery, ExtractQueryByKey, ExtractQueryResponse, ExtractWebSocket, ExtractorCache, FAQItem, FieldComponentProps, FieldValues, FormConfigProps, FormContainerProps, FormElements, FormFieldConfig, FormFieldProps, FormFunctionProps, FormManagerConfig, FormManagerProps, FormNotificationMessage, FormPageProps, FormStoreEntry, FormTranslationOptions, FormatOptions, FunctionProps, GenerateContentProps, GenerateContentRenderProps, GenericFieldApi, GenericFieldState, GenericFormApi, GetApiValuesFunction, GetFormValuesFunction, GetFunction, HeadTag, I18nConfig, IconConfig, IconsConfig, ItemContainerProps, Items, LazyLoadingConfig, LlmsTxtConfig, LlmsTxtEntry, Locale, LocalizationConfigProps, MappedContents, MappedFormItemsFunction, MappedItemsFunction, MemoizationCacheStats, MetaTag, MetadataConfig, MetadataProvider, MetadataStore, MultipleQueryResponse, MultipleWebSocketResponse, MutationActionInternal, MutationConfig, MutationItem, MutationStateInternal, MutationStoreEntry, NextMetadata, OpenGraphArticle, OpenGraphConfig, OpenGraphImage, OrganizationJsonLdInput, PageAuthState, PageConfigProps, MetadataConfig as PageMetadataProps, PageProps, PageTranslationOptions, PlatformOverrides, ProductJsonLdInput, Props, ProviderConfig, QueriesArray, QueriesProps, QueryAtIndex, QueryConfig, QueryConfigArray, QueryDefinition, QueryItem, QueryPageConfigArray, QueryProps, QueryResult, QueryStoreEntry, RenderComponentsProps, ResolvedMetadata, RobotsConfig, RobotsTxtConfig, Rules, SetFunction, SetValueFunction, SingleQueryConfig, SitemapEntry, StructuredDataConfig, Submit, SubmitKeysArg, SubmitPayload, SyncStorage, TranslateFunction, TranslationFunction, TranslationOptions, TranslationResources, TwitterCardConfig, UseApiOptions, UseCustomFormOptions, UseFormManagerProps, UseFormValuesProps, UseMetadataProps, ViewSettings, ViewSettingsContainerProps, WebSiteJsonLdInput, WebSocketDefinition, WebSocketResult, WebSocketsArray };