@llmnative/react 0.1.0

package/dist/types/src/index.d.ts

@@ -0,0 +1,56 @@
+import './globals.css';
+export { default as App } from './App';
+export { useMenu } from './App';
+export type { AppProps, AppProvidersConfig } from './App';
+export type { ServicesConfig, SupabaseProviderConfig, GoogleProviderConfig, MockProviderConfig, DataDriverName, StorageDriverName, AuthDriverName, EmailDriverName, } from './providers/manifest';
+export { Head, HeadProvider, DEFAULT_DOCUMENT_HEAD, DEFAULT_HEAD_APP_NAME, DEFAULT_LANGUAGE_HEAD, useAssetsHead, useDocumentHead, useHead, useHeadLinks, useLanguageHead, usePaginationHead, usePwaHead, useSchemaOrgHead, useSocialHead, } from './Head';
+export type { HeadController, AssetsHeadState, DocumentBaseHead, DocumentHeadState, DocumentHttpEquivMeta, HeadFontAsset, HeadLinkDescriptor, HeadLinksState, HeadMetaAttributes, HeadProviderProps, HeadScriptAsset, HeadStyleAsset, LanguageAlternateLink, LanguageHeadState, OpenGraphHeadState, PageMetadataState, PaginationHeadState, PwaIconLink, PwaHeadState, SchemaOrgHeadState, SchemaOrgJson, SocialHeadState, TwitterHeadState, } from './Head';
+export { useTheme, useThemeController, BUILT_IN_THEMES, BUILT_IN_THEME_IDS } from './Theme';
+export type { AppThemeProviderConfig, BuiltInThemeId, CardTheme, ColorScale, GalleryTheme, MenuTheme, ModalTheme, TableTheme, Theme, ThemeConfig, ThemeController, ThemeMode, ThemeDefinition, ThemePresetConfig, } from './Theme';
+export { AuthButton, useAccessToken, getAccessToken } from './auth';
+export { useGlobalVars, getGlobalVars, setGlobalVars, removeGlobalVars } from './Global';
+export type { DataProviderAdapter, RecordProps, RecordArray, DatabaseOptions, DBConfig, ReadOptions, WhereClause, OrderClause, Condition } from './providers/data/DataProvider';
+export type { OrderConfig, OrderDirection } from './libs/order';
+export { Order } from './libs/order';
+export type { TableHeaderProp, TableReorderHandler, TableReorderMeta, TableSelectionChangeHandler, TableSelectionState } from './components/ui/Table';
+export type { GallerySelectionChangeHandler, GallerySelectionState } from './components/ui/Gallery';
+export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, } from './components/widgets/Grid';
+export type { ProviderConfigurable, ProviderConfigurationState } from './providers/ProviderConfiguration';
+export { getProviderConfigurationState } from './providers/ProviderConfiguration';
+export type { MotionEffect, MotionReference, MotionRegistry, MotionStyle, MotionTransition, ReducedMotionMode, ResolvedMotionEffect } from './motion';
+export { createMotionTransition, resolveMotionEffect, useEnterMotion, useMotionEffect, useMotionState, usePressMotion } from './motion';
+export { FirebaseDataProvider } from './providers/data/firebase';
+export { SupabaseDataProvider } from './providers/data/supabase';
+export { MockDataProvider } from './providers/data/mock';
+export { useDataProvider, DataProvider } from './providers/data/DataProviderContext';
+export type { StorageProviderAdapter } from './providers/storage/StorageProvider';
+export { FirebaseStorageProvider } from './providers/storage/firebase';
+export { SupabaseStorageProvider } from './providers/storage/supabase';
+export { useStorageProvider, StorageProvider } from './providers/storage/StorageProviderContext';
+export type { AuthProviderAdapter, AuthIntent, AuthSignInOptions, UserProfile } from './providers/auth/AuthProvider';
+export { useAuthProvider, AuthProvider } from './providers/auth/AuthProviderContext';
+export { GoogleAuthProvider } from './providers/auth/google/GoogleAuthProvider';
+export { DropboxAuthProvider } from './providers/auth/dropbox/DropboxAuthProvider';
+export type { EmailProviderAdapter, EmailSendParams } from './providers/email/EmailProvider';
+export type { IconProviderAdapter, IconComponentProps } from './providers/icon/IconProvider';
+export { LucideIconProvider } from './providers/icon/LucideIconProvider';
+export { PhosphorIconProvider } from './providers/icon/PhosphorIconProvider';
+export type { PhosphorWeight } from './providers/icon/PhosphorIconProvider';
+export { IconProvider, useIconProvider, useIconController } from './providers/icon/IconProviderContext';
+export type { AppIconProviderConfig, IconController } from './providers/icon/IconProviderContext';
+export { useEmailProvider, EmailProvider } from './providers/email/EmailProviderContext';
+export { GmailEmailProvider } from './providers/email/google/GmailEmailProvider';
+export type { AIFetchConfig } from './providers/ai';
+export { getAIProviderConfigurationState } from './providers/ai';
+export { googleGetAccessToken } from './providers/auth/google/GoogleAuth';
+export { sendEmail } from './providers/email/google/email';
+export { getKeywordIdeas } from './providers/seo/google/keyword';
+export { getGoogleTrendsData, getGoogleTrendsRelated } from './providers/seo/google/trend';
+export { default as db } from './providers/data/firebase';
+export { default as storage } from './providers/storage/firebase';
+export { dropBox, useDropBoxConnect, DropBoxConnectButton } from './providers/storage/dropbox';
+export { AI } from './providers/ai';
+export { default as scrape } from './providers/scrape';
+export * from './components';
+export * from './libs';
+export * from './pages';

package/dist/types/src/libs/cache.d.ts

@@ -0,0 +1,9 @@
+export interface CacheOptions {
+    callLabel: string;
+    callKey: string;
+    callBasePath: string;
+    callService: string;
+    callFunc: Function;
+    callOptions: Object;
+}
+export declare const cache: (search: any, strategy: any, { callLabel, callKey, callBasePath, callService, callFunc, callOptions }: CacheOptions, caller?: any, storePaths?: string[]) => Promise<any>;

package/dist/types/src/libs/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/types/src/libs/converter.d.ts

@@ -0,0 +1,28 @@
+type ConverterFunction = (value: string | number | Date, format?: string) => string;
+interface ConverterCore {
+    toDate: ConverterFunction;
+    toTime: ConverterFunction;
+    toDateTime: ConverterFunction;
+    toCamel: (str: string, separator?: string, delimiter?: string[]) => string;
+    toUpper: (str: string) => string;
+    toLower: (str: string) => string;
+    toSlug: (str: string) => string;
+    subStringCount: (str: string, subStr: string) => number;
+}
+interface Converter extends ConverterCore {
+    parse: (values: Record<string, any>, pattern: string, target?: {
+        key: string;
+        value: any;
+        hideEmpty: boolean;
+    }) => string;
+    truncate: (str: string, length?: number) => string;
+    splitLast: (str: string, seps: string | string[], regException?: RegExp) => [string, string];
+    splitFirst: (str: string, seps: string | string[], regException?: RegExp) => [string, string];
+    padLeft: (str: string, length: number, char?: string, regex?: RegExp) => string;
+    padRight: (str: string, length: number, char?: string, regex?: RegExp) => string;
+    toQueryString: (params: Record<string, string>, startWith?: string, fill?: string) => string;
+    fillObject: <T>(obj: Record<string, T>, value?: any) => Record<string, any>;
+    [key: string]: ConverterCore[keyof ConverterCore] | any;
+}
+export declare const converter: Converter;
+export {};

package/dist/types/src/libs/database.d.ts

@@ -0,0 +1,3 @@
+export { default } from '../providers/data/firebase';
+export { FirebaseDataProvider } from '../providers/data/firebase';
+export { SYSTEM_FIELDS } from '../providers/data/firebase';

package/dist/types/src/libs/email.d.ts

@@ -0,0 +1,16 @@
+type Recipient = {
+    email: string;
+    name?: string;
+};
+type EmailContent = string | React.ReactNode;
+export declare function sendEmail({ to, bcc, subject, message, }: {
+    to: string | string[] | Recipient | Recipient[];
+    bcc?: string | string[];
+    subject: string;
+    message?: EmailContent;
+}): Promise<{
+    id: string;
+    threadId: string;
+    labelIds?: string[];
+}[]>;
+export {};

package/dist/types/src/libs/fetch.d.ts

@@ -0,0 +1,9 @@
+interface FetchOptions {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "PATCH";
+    headers?: Record<string, string>;
+    body?: Record<string, any> | string;
+}
+export declare function fetchRest(url: string, options?: FetchOptions | null): Promise<any>;
+export declare function fetchJson(url: string, options?: FetchOptions | null): Promise<any>;
+export declare function fetchWithRetry(url: string, options?: RequestInit, maxRetries?: number, statusNoRetry?: number[]): Promise<any | Response>;
+export {};

package/dist/types/src/libs/imageBuilder.d.ts

@@ -0,0 +1,112 @@
+/**
+ * imageBuilder — pure utility for generating SEO/performance-optimised <img> tags
+ * with srcset support. Does NOT resize images; assumes variant files already exist.
+ *
+ * Two srcset modes:
+ *   density — fixed-size images (logos, avatars): 1x / 2x / 3x descriptors
+ *             naming: image.jpg → image@2x.jpg, image@3x.jpg
+ *   width   — responsive/fluid images (hero, content): width descriptors + sizes
+ *             naming: image.jpg → image-400w.jpg, image-800w.jpg …
+ */
+export type ImgFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
+export interface ImageBuilderConfig {
+    /** URL, relative path, or data URI of the source image (used as src and as the 1x/base variant in srcset). */
+    src: string;
+    /** Alt text — required for SEO and accessibility. */
+    alt: string;
+    title?: string;
+    /** Intrinsic display width in px. Prevents CLS (Core Web Vitals). */
+    width?: number;
+    /** Intrinsic display height in px. Prevents CLS (Core Web Vitals). */
+    height?: number;
+    fit?: ImgFit;
+    position?: string;
+    /**
+     * loading="lazy" for below-the-fold images.
+     * Do NOT use on LCP images — use priority=true instead.
+     * Default: 'lazy'.
+     */
+    loading?: 'lazy' | 'eager';
+    /**
+     * Marks this as the LCP (Largest Contentful Paint) image.
+     * Sets fetchpriority="high" and loading="eager". Overrides `loading`.
+     */
+    priority?: boolean;
+    /** Default: 'async' — frees the main thread from image decoding. */
+    decoding?: 'async' | 'sync' | 'auto';
+    className?: string;
+    crossorigin?: 'anonymous' | 'use-credentials';
+    referrerpolicy?: string;
+}
+/** Density-based srcset: best for fixed-size images (logos, avatars, icons). */
+export interface SrcsetDensityConfig {
+    mode: 'density';
+    /** Pixel-density multipliers. Include 1 to make the 1x variant explicit. Default: [1, 2]. */
+    densities?: number[];
+    /**
+     * Override the suffix inserted before the extension for each density.
+     * Default: density === 1 → no suffix (uses src as-is), density > 1 → '@{d}x'
+     * Example: (2) => '-2x'  to get  image-2x.jpg instead of image@2x.jpg
+     */
+    suffix?: (density: number) => string;
+}
+/** Width-based srcset: best for responsive/fluid images (hero, content, cards). */
+export interface SrcsetWidthConfig {
+    mode: 'width';
+    /** Image widths in pixels, ascending order. Example: [400, 800, 1200]. */
+    widths: number[];
+    /**
+     * Override the suffix inserted before the extension for each width.
+     * Default: (w) => `-${w}w`  →  image-400w.jpg
+     */
+    suffix?: (width: number) => string;
+    /**
+     * CSS sizes attribute — tells the browser how wide the image renders at each breakpoint.
+     * Required for width-mode srcset to work correctly.
+     * Example: '(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 33vw'
+     */
+    sizes?: string;
+}
+export type SrcsetConfig = SrcsetDensityConfig | SrcsetWidthConfig;
+/** JSON-serialisable representation of all <img> attributes. */
+export interface ImageParams {
+    src: string;
+    alt: string;
+    title?: string;
+    width?: number;
+    height?: number;
+    srcset?: string;
+    sizes?: string;
+    style?: string;
+    loading?: 'lazy' | 'eager';
+    decoding?: 'async' | 'sync' | 'auto';
+    fetchpriority?: 'high' | 'low' | 'auto';
+    class?: string;
+    crossorigin?: string;
+    referrerpolicy?: string;
+}
+export interface UseImageResult {
+    /** Generates the <img> HTML string with all SEO/performance attributes. */
+    toHtml: (srcset?: SrcsetConfig) => string;
+    /** Generates a JSON string of all img attributes — for CMS, SSR or metadata. */
+    toJson: (srcset?: SrcsetConfig) => string;
+    /** Returns the raw ImageParams object for custom serialisation. */
+    params: (srcset?: SrcsetConfig) => ImageParams;
+}
+/**
+ * Returns toHtml / toJson / params helpers bound to the given image config.
+ * Does NOT resize images — assumes variant files already exist on the server.
+ *
+ * @example
+ * const img = useImage({ src: 'hero.jpg', alt: 'Hero', width: 800, height: 450, priority: true })
+ *
+ * // Responsive HTML with width-based srcset (files: hero-400w.jpg, hero-800w.jpg, hero-1200w.jpg)
+ * img.toHtml({ mode: 'width', widths: [400, 800, 1200], sizes: '(max-width: 640px) 100vw, 800px' })
+ *
+ * // Fixed-size HTML with density srcset (files: hero.jpg, hero@2x.jpg, hero@3x.jpg)
+ * img.toHtml({ mode: 'density', densities: [1, 2, 3] })
+ *
+ * // JSON params for CMS or SSR
+ * img.toJson({ mode: 'width', widths: [400, 800, 1200], sizes: '100vw' })
+ */
+export declare function useImage(config: ImageBuilderConfig): UseImageResult;

package/dist/types/src/libs/index.d.ts

@@ -0,0 +1,14 @@
+export { default as db } from './database';
+export { default as storage } from './storage';
+export { default as path } from './path';
+export { default as log } from './log';
+export { default as seo } from './seo';
+export * from './converter';
+export * from './sanitizer';
+export * from './email';
+export * from './fetch';
+export * from './utils';
+export * from './order';
+export { cn } from './cn';
+export { useImage } from './imageBuilder';
+export type { UseImageResult, ImageBuilderConfig, SrcsetConfig, SrcsetDensityConfig, SrcsetWidthConfig, ImageParams, ImgFit } from './imageBuilder';

package/dist/types/src/libs/locale.d.ts

@@ -0,0 +1,24 @@
+export declare const COUNTRIES: {
+    US: string;
+    CN: string;
+    IT: string;
+    FR: string;
+    DE: string;
+    ES: string;
+    PT: string;
+    RU: string;
+    JP: string;
+};
+export declare const LANGS: {
+    it: string;
+    en: string;
+    fr: string;
+    de: string;
+    es: string;
+    pt: string;
+    ru: string;
+    ja: string;
+    ko: string;
+};
+export declare const currentCountry: (code?: boolean) => string;
+export declare const currentLang: (code?: boolean) => string;

package/dist/types/src/libs/log.d.ts

@@ -0,0 +1,2 @@
+declare const setLog: (path: string, action: "create" | "update" | "delete", record: any, recordKey?: string) => Promise<void>;
+export default setLog;

package/dist/types/src/libs/order.d.ts

@@ -0,0 +1,14 @@
+import type { RecordProps } from '../providers/data/DataProvider';
+export type OrderDirection = 'asc' | 'desc';
+export type OrderConfig = {
+    field: string;
+    dir?: OrderDirection;
+};
+export declare const DEFAULT_ORDER: Required<OrderConfig>;
+export declare const Order: {
+    normalize(order?: OrderConfig | null): Required<OrderConfig> | undefined;
+    toggle(current: OrderConfig | undefined, field: string): Required<OrderConfig>;
+    compareValues(a: unknown, b: unknown, dir?: OrderDirection): number;
+    compareRecords<T extends RecordProps>(a: T, b: T, order: OrderConfig): number;
+    records<T extends RecordProps>(records: T[] | undefined, order?: OrderConfig | null): T[] | undefined;
+};

package/dist/types/src/libs/path.d.ts

@@ -0,0 +1,26 @@
+interface PathUtils {
+    basename(path: string): string;
+    extname(path: string): string;
+    dirname(path: string): string;
+    filename(path: string): string;
+    parentBasename(path: string): string;
+    parentDirname(path: string): string;
+    parentFilename(path: string): string;
+    append(path: string, suffix: string): string;
+    prepend(path: string, prefix: string): string;
+    changeFilename(path: string, options?: {
+        prefix?: string;
+        suffix?: string;
+        ext?: string | null;
+    }): string;
+    join(...paths: string[]): string;
+    parse(path: string): {
+        root: string;
+        dir: string;
+        base: string;
+        ext: string;
+        name: string;
+    };
+}
+declare const path: PathUtils;
+export default path;

package/dist/types/src/libs/sanitizer.d.ts

@@ -0,0 +1,38 @@
+import { converter } from "./converter";
+interface ExclusionItem {
+    phrase: string;
+}
+interface Transformation {
+    pattern: string;
+    replace: string;
+}
+type ConverterMask = keyof typeof converter | {
+    func: keyof typeof converter;
+    arg?: string;
+};
+export interface SanitizerRule {
+    description?: string;
+    exclusions?: ExclusionItem[];
+    transformations?: Transformation[];
+    mask?: ConverterMask[];
+}
+export type SanitizerConfig = Record<string, SanitizerRule>;
+/** Map of field patterns → rule names */
+export interface SanitizerMatch {
+    pattern: string;
+    use: keyof SanitizerConfig;
+}
+export declare const NORMALIZE_MAP: Record<string, string>;
+export declare function normalizeVisualChars(input: string): string;
+export declare class Sanitizer {
+    private config;
+    private matches;
+    constructor(config?: SanitizerConfig, matches?: SanitizerMatch[]);
+    apply(ruleName: keyof SanitizerConfig, value: any, autoCast?: boolean): any;
+    applyMatches<T extends Record<string, any>>(obj: T, autoCast?: boolean): T;
+    getOptions(): Record<string, string>[];
+    addRule(name: keyof SanitizerConfig, rule: SanitizerRule): void;
+    addMatch(pattern: string, use: keyof SanitizerConfig): void;
+    private wildcardToRegExp;
+}
+export {};

package/dist/types/src/libs/seo.d.ts

@@ -0,0 +1,8 @@
+import { getKeywordIdeas } from "../providers/seo/google/keyword";
+import { getGoogleTrendsData } from "../providers/seo/google/trend";
+declare const seo: {
+    keyword: typeof getKeywordIdeas;
+    trend: typeof getGoogleTrendsData;
+    serp: null;
+};
+export default seo;

package/dist/types/src/libs/storage.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../providers/storage/firebase';
+export { FirebaseStorageProvider } from '../providers/storage/firebase';

package/dist/types/src/libs/utils.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+import { RecordProps } from '../providers/data/DataProvider';
+export declare const decodeJWT: (token: string) => any;
+export declare const copyToClipboard: (text: string) => void;
+export declare const trimPath: (path?: string) => string;
+export declare const normalizePath: (path?: string) => string;
+export declare const trimSlash: (path?: string | number | boolean) => string;
+export declare const normalizeKey: (key?: string | number | boolean) => string;
+export declare const dirname: (path: string) => string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function proxy(url: string, format?: string): string;
+export declare function generateUniqueId(name?: null): string;
+export declare function eventClosest(e: Event, tagName: string): HTMLElement | null;
+export declare const substrCount: (str: string, sub: string) => number;
+export declare const replacePlaceholders: (pattern: string, arrPath: string[]) => string;
+export declare const checkConditions: (conds: Array<{
+    key: string;
+    value: string;
+    operator: string;
+}>, metaObject: {
+    [key: string]: string | undefined;
+}, tokens: string[]) => boolean;
+export declare const crc32: (str: string) => number;
+export declare const ucfirst: (str?: string) => string;
+export declare const loadScripts: (scriptData: Array<{
+    src: string;
+    [key: string]: any;
+}>) => void;
+export declare const intersectObjects: (obj1: {
+    [key: string]: any;
+}, obj2: {
+    [key: string]: any;
+}) => {
+    [key: string]: any;
+};
+export declare const replaceVariables: (pattern: string, metaObject: {
+    [key: string]: string | undefined;
+}) => string;
+export declare const arrayUnique: <T>(array: T[], key?: keyof T) => T[];
+export declare const isEmpty: (data: any) => boolean;
+export declare function safeClone<T>(obj: T): T;
+export declare function base64Encode(input: string | Buffer | ArrayBuffer): string;
+export declare function arraysEqual(a: any[], b: any[]): boolean;
+export declare function sanitizeKey(str: string): string;
+/**
+ * Checks if the event target or any of its parent elements is an interactive element
+ * (link, button, input, textarea, or select)
+ * @param e The event to check
+ * @returns true if the target or any parent is an interactive element
+ */
+export declare function isInteractiveElement(e: Event | React.MouseEvent, exclude?: string): boolean;
+export declare const render2Base64: (arrayBuffer: ArrayBuffer) => string;
+export declare const base64ToBlob: (base64: string, type: string) => Blob | undefined;
+export declare const base64ToUrl: (base64: string, type: string) => string | undefined;
+export declare const getRecordValue: (record?: RecordProps, name?: string) => any;
+export declare const cleanRecord: (record: RecordProps | undefined) => RecordProps;
+export declare const smartTypeCast: (value: any) => string | number | boolean | null | undefined;

package/dist/types/src/motion.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+export type ReducedMotionMode = 'respect-user' | 'always' | 'never';
+export type MotionStyle = React.CSSProperties;
+export type MotionReference = string | MotionEffect | false;
+export interface MotionTransition {
+    duration?: number;
+    easing?: string;
+    delay?: number;
+    properties?: string[];
+}
+export interface MotionEffect {
+    from?: MotionStyle;
+    to?: MotionStyle;
+    transition?: MotionTransition;
+    reducedMotion?: ReducedMotionMode;
+}
+export type MotionRegistry = Record<string, MotionEffect>;
+export interface ResolvedMotionEffect {
+    from: MotionStyle;
+    to: MotionStyle;
+    transition: Required<MotionTransition>;
+    reducedMotion: ReducedMotionMode;
+    transitionValue: string;
+}
+export declare const createMotionTransition: (transition: Required<MotionTransition>) => string;
+export declare const resolveMotionEffect: (reference: MotionReference | undefined, registry?: MotionRegistry, fallback?: MotionReference) => ResolvedMotionEffect;
+export declare const useMotionEffect: (reference?: MotionReference, fallback?: MotionReference) => ResolvedMotionEffect;
+export declare const useMotionState: (active: boolean, reference?: MotionReference, fallback?: MotionReference, baseStyle?: React.CSSProperties) => React.CSSProperties;
+export declare const usePressMotion: (disabled?: boolean, baseStyle?: React.CSSProperties, reference?: MotionReference, fallback?: MotionReference) => {
+    style: React.CSSProperties;
+    pressHandlers: {
+        onMouseDown: () => false | void;
+        onMouseUp: () => void;
+        onMouseLeave: () => void;
+        onBlur: () => void;
+    };
+};
+export declare const useEnterMotion: (baseStyle?: React.CSSProperties, reference?: MotionReference, fallback?: MotionReference) => React.CSSProperties;

package/dist/types/src/pages/Blog.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare function Blog(): React.JSX.Element;
+export default Blog;

package/dist/types/src/pages/BlogPost.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { PROMPTS } from '../conf/Prompt';
+type PromptKey = keyof typeof PROMPTS;
+interface ConfigVariables {
+    lang: string;
+    voice: string;
+    style: string;
+    limit: string;
+}
+export default function BlogPost({ data, promptTopic, onChange, value }: {
+    data?: ConfigVariables;
+    promptTopic?: PromptKey;
+    onChange?: (e: any) => void;
+    value?: any;
+}): React.JSX.Element;
+export {};

package/dist/types/src/pages/Helper.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare global {
+    interface Window {
+        bootstrap: any;
+    }
+}
+declare function Helper(): React.JSX.Element;
+export default Helper;

package/dist/types/src/pages/NotFound.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const NotFound: React.FC;
+export default NotFound;

package/dist/types/src/pages/Users.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare function Users(): React.JSX.Element;
+export default Users;

package/dist/types/src/pages/index.d.ts

@@ -0,0 +1,3 @@
+export { default as PageUsers } from './Users';
+export { default as PageHelper } from './Helper';
+export { default as PageBlog } from './Blog';

package/dist/types/src/providers/ProviderConfiguration.d.ts

@@ -0,0 +1,12 @@
+export interface ProviderConfigurationState {
+    configured: boolean;
+    reason?: string;
+    missingKeys?: string[];
+}
+export interface ProviderConfigurable {
+    isConfigured?(): boolean;
+    getConfigurationState?(): ProviderConfigurationState;
+}
+export declare const getMissingKeys: (config: Record<string, unknown> | undefined, keys: string[], prefix?: string) => string[];
+export declare const createConfigurationState: (provider: string, missingKeys: string[]) => ProviderConfigurationState;
+export declare const getProviderConfigurationState: (provider: ProviderConfigurable | null | undefined, fallbackName?: string) => ProviderConfigurationState;