@llmnative/react 0.1.0

package/dist/types/src/components/widgets/Prompt.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { AIFetchConfig } from '../../providers/ai';
+import { PromptVariables } from '../../conf/Prompt';
+import { FormFieldProps } from './Form';
+export declare enum PromptMode {
+    EDITOR = "editor",
+    LIVE = "live"
+}
+type PromptOptions = AIFetchConfig & {
+    value: string;
+};
+type OnRunPrompt = (prompt: string, config: AIFetchConfig, data?: PromptVariables) => Promise<string>;
+export interface PromptProps extends FormFieldProps {
+    mode?: PromptMode;
+    onRunPrompt?: OnRunPrompt;
+    renderPromptDisabled?: (props: Omit<FormFieldProps, "defaultValue">) => React.ReactNode;
+    rows?: number;
+    defaultValue?: {
+        value?: string;
+        enabled?: boolean;
+        role?: string;
+        language?: string;
+        voice?: string;
+        style?: string;
+        model?: string;
+        temperature?: number;
+    };
+}
+export declare const Prompt: ({ mode, onRunPrompt, renderPromptDisabled, ...props }: PromptProps) => React.JSX.Element;
+export declare const runPrompt: (options: PromptOptions, data?: PromptVariables, onRunPrompt?: OnRunPrompt) => Promise<string>;
+export {};

package/dist/types/src/components/widgets/TabDynamic.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { TabPosition } from '../ui/Tab';
+import { FieldOnChange } from './Form';
+interface TabDynamicProps {
+    children: React.ReactNode | ((record: any) => React.ReactNode);
+    name: string;
+    onChange?: FieldOnChange;
+    onAdd?: (value: any[]) => void;
+    onRemove?: (index: number) => void;
+    value?: any[];
+    label?: string;
+    min?: number;
+    max?: number;
+    activeIndex?: number;
+    title?: string;
+    readOnly?: boolean;
+    tabPosition?: TabPosition;
+}
+declare const TabDynamic: ({ children, name, onChange, onAdd, onRemove, label, min, max, activeIndex, title, readOnly, tabPosition }: TabDynamicProps) => React.JSX.Element;
+export default TabDynamic;

package/dist/types/src/components/widgets/grid-core/GridArray.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridArrayProps } from "./types";
+declare function GridArray<TRecord extends RecordProps>(props: GridArrayProps<TRecord>): React.JSX.Element;
+export default GridArray;

package/dist/types/src/components/widgets/grid-core/GridCore.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridCoreProps } from "./types";
+declare function GridCore<TRecord extends RecordProps>({ records, recordId, sourcePath, columns, actions, form, routeSync, header, footer, layout, sticky, wrapClass, loading, title, sortable, pagination, selection, selectedKeys, defaultSelectedKeys, onSelectionChange, onClickRow, reorderable, onReorder, groupBy, onSave, onDelete, onAfterAction, createRecordKey, audit, transformRecords, }: GridCoreProps<TRecord>): React.JSX.Element;
+export default GridCore;

package/dist/types/src/components/widgets/grid-core/GridDB.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridDBProps } from "./types";
+declare function GridDB<TRecord extends RecordProps = RecordProps>({ path, where, order, fieldMap, onLoad, recordId, ...rest }: GridDBProps<TRecord>): React.JSX.Element;
+export default GridDB;

package/dist/types/src/components/widgets/grid-core/GridGalleryView.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridGalleryViewProps } from "./types";
+declare function GridGalleryView<TRecord extends RecordProps>({ records, recordId, sortable, pagination, selection, selectedKeys, onSelectionChange, onClickRow, groupBy, wrapClass, }: GridGalleryViewProps<TRecord>): React.JSX.Element;
+export default GridGalleryView;

package/dist/types/src/components/widgets/grid-core/GridTableView.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridTableViewProps } from "./types";
+declare function GridTableView<TRecord extends RecordProps>({ records, recordId, columns, runAction, sortable, pagination, selection, selectedKeys, onSelectionChange, onClickRow, reorderable, onReorder, activeKey, wrapClass, }: GridTableViewProps<TRecord>): React.JSX.Element;
+export default GridTableView;

package/dist/types/src/components/widgets/grid-core/index.d.ts

@@ -0,0 +1,7 @@
+export { default as GridCore } from "./GridCore";
+export { default as GridArray } from "./GridArray";
+export { default as GridDB } from "./GridDB";
+export { default as GridTableView } from "./GridTableView";
+export { default as GridGalleryView } from "./GridGalleryView";
+export { resolveGridPathFromUrl } from "./resolveGridPathFromUrl";
+export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridBaseProps, GridCellContext, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridProps, GridReorderHandler, GridReorderMeta, GridRecordKey, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, } from "./types";

package/dist/types/src/components/widgets/grid-core/resolveGridPathFromUrl.d.ts

@@ -0,0 +1 @@
+export declare function resolveGridPathFromUrl(pathname: string): string | undefined;

package/dist/types/src/components/widgets/grid-core/types.d.ts

@@ -0,0 +1,227 @@
+import React from "react";
+import { type OrderConfig } from "../../../libs/order";
+import { type PaginationParams } from "../../ui/Pagination";
+import { type DatabaseOptions, type RecordProps } from "../../../providers/data/DataProvider";
+export type GridLayout = "table" | "gallery";
+export type GridSticky = "top" | "bottom";
+export type GridSelectionMode = false | "single" | "multiple";
+export type GridRecordKey<TRecord> = keyof TRecord | ((record: TRecord) => string);
+export type GridFormat = "text" | "email" | "date" | "datetime" | "badge" | "image" | "boolean" | "json";
+export type GridCellContext<TRecord> = {
+    record: TRecord;
+    value: unknown;
+    key: string;
+    rowIndex: number;
+    runAction: (actionKey: string) => void;
+};
+export type GridColumn<TRecord> = {
+    key: keyof TRecord | string;
+    label: string;
+    sortable?: boolean;
+    className?: string;
+    render?: GridFormat | ((ctx: GridCellContext<TRecord>) => React.ReactNode);
+};
+export type GridSelectionState<TRecord> = {
+    keys: string[];
+    records: TRecord[];
+    hasSelection: boolean;
+    clear: () => void;
+};
+export type GridSelectionChangeHandler<TRecord> = (selection: GridSelectionState<TRecord>) => void;
+export type GridReorderMeta<TRecord> = {
+    fromIndex: number;
+    toIndex: number;
+    record: TRecord;
+};
+export type GridReorderHandler<TRecord> = (records: TRecord[], meta: GridReorderMeta<TRecord>) => void;
+export type GridActionContext<TRecord> = {
+    actionKey: string;
+    record?: TRecord;
+    recordKey?: string;
+    rowIndex?: number;
+    isNewRecord: boolean;
+    runAction: (actionKey: string, record?: TRecord) => void;
+};
+export type GridModalActionContext<TRecord> = {
+    actionKey: string;
+    record?: TRecord;
+    recordKey?: string;
+    rowIndex?: number;
+    isNewRecord: boolean;
+    runAction: (actionKey: string) => void;
+};
+type GridActionPredicate<TRecord> = boolean | ((record?: TRecord) => boolean);
+export type GridModalAction<TRecord> = {
+    kind: "modal";
+    label?: string;
+    icon?: string;
+    visible?: GridActionPredicate<TRecord>;
+    disabled?: GridActionPredicate<TRecord>;
+    title?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    size?: "sm" | "md" | "lg" | "xl" | "fullscreen";
+    position?: "center" | "top" | "left" | "right" | "bottom";
+    buttonFullscreen?: boolean;
+    header?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    body?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    footer?: React.ReactNode | false | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+};
+export type GridRouteAction<TRecord> = {
+    kind: "route";
+    label?: string;
+    icon?: string;
+    visible?: GridActionPredicate<TRecord>;
+    disabled?: GridActionPredicate<TRecord>;
+    to: string | ((ctx: GridActionContext<TRecord>) => string);
+};
+export type GridExternalAction<TRecord> = {
+    kind: "external";
+    label?: string;
+    icon?: string;
+    visible?: GridActionPredicate<TRecord>;
+    disabled?: GridActionPredicate<TRecord>;
+    href: string | ((ctx: GridActionContext<TRecord>) => string);
+};
+export type GridInlineAction<TRecord> = {
+    kind: "inline";
+    label?: string;
+    icon?: string;
+    visible?: GridActionPredicate<TRecord>;
+    disabled?: GridActionPredicate<TRecord>;
+    run: (ctx: GridActionContext<TRecord>) => void | Promise<void>;
+};
+export type GridDeleteAction<TRecord> = {
+    kind: "delete";
+    label?: string;
+    icon?: string;
+    visible?: GridActionPredicate<TRecord>;
+    disabled?: GridActionPredicate<TRecord>;
+    title?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    size?: "sm" | "md" | "lg" | "xl" | "fullscreen";
+    position?: "center" | "top" | "left" | "right" | "bottom";
+    buttonFullscreen?: boolean;
+    header?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    body?: React.ReactNode | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+    footer?: React.ReactNode | false | ((ctx: GridModalActionContext<TRecord>) => React.ReactNode);
+};
+export type GridAction<TRecord> = GridModalAction<TRecord> | GridRouteAction<TRecord> | GridExternalAction<TRecord> | GridInlineAction<TRecord> | GridDeleteAction<TRecord>;
+export type GridActions<TRecord> = Array<"add" | "edit" | "delete"> | Record<string, GridAction<TRecord> | false>;
+export type GridHeaderContext<TRecord> = {
+    title?: React.ReactNode;
+    records: TRecord[];
+    selection: GridSelectionState<TRecord>;
+    runAction: (actionKey: string, record?: TRecord) => void;
+};
+export type GridFooterContext<TRecord> = {
+    records: TRecord[];
+    selection: GridSelectionState<TRecord>;
+    runAction: (actionKey: string, record?: TRecord) => void;
+};
+export type GridFormContext<TRecord> = GridActionContext<TRecord> & {
+    record: TRecord | undefined;
+};
+export type GridMutationSaveArgs<TRecord> = {
+    record?: TRecord;
+    action: "create" | "update";
+    storagePath?: string;
+};
+export type GridMutationSaveHandler<TRecord> = (args: GridMutationSaveArgs<TRecord>) => Promise<string | undefined>;
+export type GridMutationDeleteArgs<TRecord> = {
+    record?: TRecord;
+};
+export type GridMutationDeleteHandler<TRecord> = (args: GridMutationDeleteArgs<TRecord>) => Promise<string | undefined>;
+export type GridAfterActionArgs<TRecord> = {
+    record?: TRecord;
+    action: "create" | "update" | "delete";
+};
+export type GridAfterActionHandler<TRecord> = (args: GridAfterActionArgs<TRecord>) => Promise<boolean>;
+export type GridRouteSync = {
+    edit?: boolean;
+};
+export type GridPresentation = {
+    layout?: GridLayout;
+    sticky?: GridSticky;
+    wrapClass?: string;
+    loading?: boolean;
+    title?: React.ReactNode;
+};
+export type GridBehavior<TRecord> = {
+    sortable?: boolean | OrderConfig;
+    pagination?: PaginationParams;
+    selection?: GridSelectionMode;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onSelectionChange?: GridSelectionChangeHandler<TRecord>;
+    onClickRow?: (record: TRecord) => void;
+    reorderable?: boolean;
+    onReorder?: GridReorderHandler<TRecord>;
+    groupBy?: keyof TRecord | string | Array<keyof TRecord | string>;
+};
+export type GridPersistence<TRecord> = {
+    onSave?: GridMutationSaveHandler<TRecord>;
+    onDelete?: GridMutationDeleteHandler<TRecord>;
+    onAfterAction?: GridAfterActionHandler<TRecord>;
+    createRecordKey?: (record: TRecord) => string;
+    audit?: boolean;
+};
+export type GridTransform<TRecord> = {
+    transformRecords?: (records: TRecord[]) => TRecord[] | Promise<TRecord[]>;
+};
+export type GridBaseProps<TRecord> = GridPresentation & GridBehavior<TRecord> & GridPersistence<TRecord> & GridTransform<TRecord> & {
+    columns?: GridColumn<TRecord>[];
+    actions?: GridActions<TRecord>;
+    form?: React.ReactElement | ((ctx: GridFormContext<TRecord>) => React.ReactNode);
+    routeSync?: GridRouteSync;
+    header?: React.ReactNode | ((ctx: GridHeaderContext<TRecord>) => React.ReactNode);
+    footer?: React.ReactNode | ((ctx: GridFooterContext<TRecord>) => React.ReactNode);
+};
+export type GridCoreProps<TRecord extends RecordProps> = GridBaseProps<TRecord> & {
+    records: TRecord[];
+    recordId: GridRecordKey<TRecord>;
+    sourcePath?: string;
+};
+export type GridArrayProps<TRecord extends RecordProps> = GridBaseProps<TRecord> & {
+    records: TRecord[];
+    recordId: GridRecordKey<TRecord>;
+};
+export type GridDBQuery = Pick<DatabaseOptions, "where" | "order" | "fieldMap" | "onLoad">;
+export type GridDBPath = string | "fromUrl";
+export type GridDBProps<TRecord extends RecordProps = RecordProps> = GridBaseProps<TRecord> & GridDBQuery & {
+    path: GridDBPath;
+    recordId?: GridRecordKey<TRecord>;
+};
+export type GridGatewayArrayProps<TRecord extends RecordProps> = GridArrayProps<TRecord> & {
+    path?: never;
+};
+export type GridGatewayDBProps<TRecord extends RecordProps = RecordProps> = GridDBProps<TRecord> & {
+    records?: never;
+};
+export type GridProps<TRecord extends RecordProps = RecordProps> = GridGatewayArrayProps<TRecord> | GridGatewayDBProps<TRecord>;
+export type GridTableViewProps<TRecord extends RecordProps> = {
+    records: TRecord[];
+    recordId: GridRecordKey<TRecord>;
+    columns: GridColumn<TRecord>[];
+    runAction: (actionKey: string, record?: TRecord) => void;
+    sortable?: boolean | OrderConfig;
+    pagination?: PaginationParams;
+    selection?: GridSelectionMode;
+    selectedKeys?: string[];
+    onSelectionChange?: GridSelectionChangeHandler<TRecord>;
+    onClickRow?: (record: TRecord) => void;
+    reorderable?: boolean;
+    onReorder?: GridReorderHandler<TRecord>;
+    activeKey?: string | null;
+    wrapClass?: string;
+};
+export type GridGalleryViewProps<TRecord extends RecordProps> = {
+    records: TRecord[];
+    recordId: GridRecordKey<TRecord>;
+    sortable?: boolean | OrderConfig;
+    pagination?: PaginationParams;
+    selection?: GridSelectionMode;
+    selectedKeys?: string[];
+    onSelectionChange?: GridSelectionChangeHandler<TRecord>;
+    onClickRow?: (record: TRecord) => void;
+    groupBy?: keyof TRecord | string | Array<keyof TRecord | string>;
+    wrapClass?: string;
+};
+export {};

package/dist/types/src/components/widgets/grid-core/useGridActions.d.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import { type FormRef } from "../Form";
+import { type DataProviderAdapter, type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridAction, type GridActionContext, type GridActions, type GridFormContext, type GridModalActionContext, type GridRecordKey } from "./types";
+export type GridActiveAction<TRecord extends RecordProps> = {
+    actionKey: string;
+    record?: TRecord;
+};
+type UseGridActionsArgs<TRecord extends RecordProps> = {
+    actions?: GridActions<TRecord>;
+    form?: React.ReactElement | ((ctx: GridFormContext<TRecord>) => React.ReactNode);
+    routeSync?: {
+        edit?: boolean;
+    };
+    preparedRecords: TRecord[];
+    recordId: GridRecordKey<TRecord>;
+    sourcePath?: string;
+    db: DataProviderAdapter;
+    onSave?: (args: {
+        record?: TRecord;
+        action: "create" | "update";
+        storagePath?: string;
+    }) => Promise<string | undefined>;
+    onDelete?: (args: {
+        record?: TRecord;
+    }) => Promise<string | undefined>;
+    onAfterAction?: (args: {
+        record?: TRecord;
+        action: "create" | "update" | "delete";
+    }) => Promise<boolean>;
+    createRecordKey?: (record: TRecord) => string;
+    audit?: boolean;
+};
+declare function useGridActions<TRecord extends RecordProps>({ actions, form, routeSync, preparedRecords, recordId, sourcePath, db, onSave, onDelete, onAfterAction, createRecordKey, audit, }: UseGridActionsArgs<TRecord>): {
+    normalizedActions: Record<string, GridAction<TRecord>>;
+    activeAction: GridActiveAction<TRecord> | null;
+    activeActionConfig: GridAction<TRecord> | undefined;
+    activeActionBody: string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+    activeKey: string | null;
+    runAction: (actionKey: string, record?: TRecord) => Promise<void>;
+    runModalAction: (actionKey: string) => Promise<void>;
+    close: () => void;
+    getActionContext: (actionKey: string, record?: TRecord) => GridActionContext<TRecord>;
+    getModalActionContext: (actionKey: string, record?: TRecord) => GridModalActionContext<TRecord>;
+    getRecordKey: (record: TRecord) => string;
+    formRef: React.MutableRefObject<FormRef | undefined>;
+    gridHashId: string;
+};
+export default useGridActions;

package/dist/types/src/components/widgets/grid-core/useGridColumns.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridColumn } from "./types";
+type UseGridColumnsArgs<TRecord extends RecordProps> = {
+    columns?: GridColumn<TRecord>[];
+    records: TRecord[];
+    form?: React.ReactElement | ((ctx: any) => React.ReactNode);
+};
+declare function useGridColumns<TRecord extends RecordProps>({ columns, records, form, }: UseGridColumnsArgs<TRecord>): GridColumn<TRecord>[];
+export default useGridColumns;

package/dist/types/src/components/widgets/grid-core/useGridDBRecords.d.ts

@@ -0,0 +1,10 @@
+import { type DatabaseOptions, type RecordProps } from "../../../providers/data/DataProvider";
+type UseGridDBRecordsArgs = {
+    path?: string;
+    where?: DatabaseOptions["where"];
+    order?: DatabaseOptions["order"];
+    fieldMap?: DatabaseOptions["fieldMap"];
+    onLoad?: DatabaseOptions["onLoad"];
+};
+declare function useGridDBRecords<TRecord extends RecordProps>({ path, where, order, fieldMap, onLoad, }: UseGridDBRecordsArgs): TRecord[];
+export default useGridDBRecords;

package/dist/types/src/components/widgets/grid-core/useGridPreparedRecords.d.ts

@@ -0,0 +1,10 @@
+import { type RecordProps } from "../../../providers/data/DataProvider";
+type UseGridPreparedRecordsArgs<TRecord extends RecordProps> = {
+    records: TRecord[];
+    transformRecords?: (records: TRecord[]) => TRecord[] | Promise<TRecord[]>;
+};
+declare function useGridPreparedRecords<TRecord extends RecordProps>({ records, transformRecords, }: UseGridPreparedRecordsArgs<TRecord>): {
+    preparedRecords: TRecord[];
+    loading: boolean;
+};
+export default useGridPreparedRecords;

package/dist/types/src/components/widgets/grid-core/useGridSelection.d.ts

@@ -0,0 +1,13 @@
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridSelectionState } from "./types";
+type UseGridSelectionArgs<TRecord extends RecordProps> = {
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onSelectionChange?: (selection: GridSelectionState<TRecord>) => void;
+};
+declare function useGridSelection<TRecord extends RecordProps>({ selectedKeys, defaultSelectedKeys, onSelectionChange, }: UseGridSelectionArgs<TRecord>): {
+    activeSelectionKeys: string[];
+    selectionState: GridSelectionState<TRecord>;
+    handleSelectionChange: (nextSelection: GridSelectionState<TRecord>) => void;
+};
+export default useGridSelection;

package/dist/types/src/components/widgets/grid-core/utils.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { type OrderConfig } from "../../../libs/order";
+import { type RecordProps } from "../../../providers/data/DataProvider";
+import { type GridAction, type GridActions, type GridColumn, type GridRecordKey } from "./types";
+export declare const isExternalUrl: (value: string) => boolean;
+export declare const sanitizeHashPart: (value: string) => string;
+export declare const getRecordKeyResolver: <TRecord extends RecordProps>(recordId: GridRecordKey<TRecord>) => (record: TRecord) => string;
+export declare const buildDisplayRecords: <TRecord extends RecordProps>(records: TRecord[], columns: GridColumn<TRecord>[], runAction: (actionKey: string, record?: TRecord) => void) => TRecord[];
+export declare const inferColumns: <TRecord extends RecordProps>(columns: GridColumn<TRecord>[] | undefined, records: TRecord[], form: React.ReactElement | ((ctx: any) => React.ReactNode) | undefined) => GridColumn<TRecord>[];
+export declare const normalizeActions: <TRecord extends RecordProps>(actions: GridActions<TRecord> | undefined, hasForm: boolean) => Record<string, GridAction<TRecord>>;
+export declare const isActionVisible: <TRecord extends RecordProps>(action: GridAction<TRecord> | undefined, record?: TRecord) => boolean;
+export declare const isActionDisabled: <TRecord extends RecordProps>(action: GridAction<TRecord> | undefined, record?: TRecord) => boolean;
+export declare const getActionLabel: (actionKey: string, action: GridAction<any> | undefined) => string;
+export declare const resolveInitialOrder: (sortable: boolean | OrderConfig | undefined) => OrderConfig | undefined;

package/dist/types/src/conf/Prompt.d.ts

@@ -0,0 +1,84 @@
+export declare const PROMPT_CLEANUP = "Please ignore all previous instructions.";
+export declare const PROMPT_NO_REFERENCE = "Do not repeat yourself. Do not self reference. Do not explain what you are doing.";
+export declare const PROMPTS: {
+    SEARCH_INTENT_FROM_KEYWORDS: string;
+    RELATED_KEYWORD_GENERATOR: string;
+    LONG_TAIL_KEYWORD_GENERATOR: string;
+    KEYWORD_STRATEGY: string;
+    GENERATE_BLOG_POST_TITLES: string;
+    GENERATE_BLOG_POST_DESCRIPTIONS: string;
+    GENERATE_BLOG_POST_OUTLINE: string;
+    GENERATE_COMPLETE_BLOG_POST_FROM_OUTLINE: string;
+    GENERATE_COMPLETE_BLOG_POST_FROM_TOPIC: string;
+    GENERATE_INTRODUCTION_USING_FRAMEWORK: string;
+    GENERATE_PARAGRAPH_OF_TEXT: string;
+    GENERATE_DICTIONARY: string;
+    GENERATE_FREE: string;
+};
+export declare const PROMPTS_ROLE: {
+    SEARCH_INTENT_FROM_KEYWORDS: string[];
+    RELATED_KEYWORD_GENERATOR: string[];
+    LONG_TAIL_KEYWORD_GENERATOR: string[];
+    KEYWORD_STRATEGY: string[];
+    GENERATE_BLOG_POST_TITLES: string[];
+    GENERATE_BLOG_POST_DESCRIPTIONS: string[];
+    GENERATE_BLOG_POST_OUTLINE: string[];
+    GENERATE_COMPLETE_BLOG_POST_FROM_OUTLINE: string[];
+    GENERATE_COMPLETE_BLOG_POST_FROM_TOPIC: string[];
+    GENERATE_INTRODUCTION_USING_FRAMEWORK: string[];
+    GENERATE_PARAGRAPH_OF_TEXT: string[];
+    GENERATE_DICTIONARY: string[];
+    GENERATE_FREE: string[];
+};
+export declare const LABELS: {
+    SEARCH_INTENT_FROM_KEYWORDS: string;
+    RELATED_KEYWORD_GENERATOR: string;
+    LONG_TAIL_KEYWORD_GENERATOR: string;
+    KEYWORD_STRATEGY: string;
+    GENERATE_BLOG_POST_TITLES: string;
+    GENERATE_BLOG_POST_DESCRIPTIONS: string;
+    GENERATE_BLOG_POST_OUTLINE: string;
+    GENERATE_COMPLETE_BLOG_POST_FROM_OUTLINE: string;
+    GENERATE_COMPLETE_BLOG_POST_FROM_TOPIC: string;
+    GENERATE_INTRODUCTION_USING_FRAMEWORK: string;
+    GENERATE_PARAGRAPH_OF_TEXT: string;
+    GENERATE_DICTIONARY: string;
+    GENERATE_FREE: string;
+};
+export declare const getPromptVoice: () => string;
+export declare const getPromptStyle: () => string;
+export declare const getPromptCountries: () => string[];
+export declare const getPromptLangs: () => string[];
+export declare const getPromptVoices: () => string[];
+export declare const getPromptStyles: () => string[];
+export declare const getPrompt: (strategy: keyof typeof PROMPTS) => {
+    prompt: string;
+    label: string;
+};
+export declare const getPromptOutline: () => string;
+export declare const getPromptRole: (strategy: keyof typeof PROMPTS_ROLE) => string[];
+export declare const setPrompt: (prompt: string, configVariables: {
+    lang?: string;
+    voice?: string;
+    style?: string;
+    limit?: string;
+}, userInput: string) => string;
+export interface PromptVariables {
+    [key: string]: any;
+}
+export declare class Prompt {
+    static getRoles(): string[];
+    static getLangs(): string[];
+    static getCountries(): string[];
+    static getVoices(): string[];
+    static getStyles(): string[];
+    static defaults(): {
+        role: string;
+        language: string;
+        country: string;
+        voice: string;
+        style: string;
+    };
+    static parseRole(role?: string, variables?: PromptVariables): string;
+    static parsePrompt(prompt: string, variables?: PromptVariables): string;
+}

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

@@ -0,0 +1,96 @@
+export declare const FIREBASE_BUCKET_ERRORS = "errors";
+export declare const FIREBASE_BUCKET_METAOBJECT = "metaobject";
+export declare const FIREBASE_BUCKET_DICTIONARY = "dictionary";
+export declare const FIREBASE_BUCKET_SITEMAP = "sitemap";
+export declare const FIREBASE_BUCKET_SITETREE = "sitetree";
+export declare const FIREBASE_BUCKET_AICHAT = "aichat";
+export declare const FIREBASE_BUCKET_SCRAPE = "scrape";
+export declare const SEP = "/";
+export declare const DOT = ".";
+export declare const DEFAULT_LANG = "it";
+export declare const consoleLog: (...args: any[]) => void;
+export interface PageRawBase {
+    path: string;
+    strategy: string;
+    caller: string;
+    relRule: string;
+    relData: string;
+}
+export declare const defaultPageRawBase: {
+    path: string;
+    strategy: string;
+    caller: string;
+    relRule: string;
+    relData: string;
+};
+interface Image {
+    thumbnail: string;
+    original: string;
+    original_width: number;
+    original_height: number;
+    alt: string;
+}
+interface Section {
+    title: string;
+    paragraph: string[];
+    image: Image;
+}
+export interface Page {
+    meta: {
+        category: string;
+        title: string;
+        description: string;
+        keyword: string;
+        searchIntent: string;
+    };
+    header: {
+        title: string;
+        content: string;
+    };
+    footer: {
+        content: {
+            title: string;
+            paragraph: string[];
+        };
+    };
+    sections: Section[];
+    image: Image;
+    gallery: {
+        title: string;
+        description: string;
+        slides: Image[];
+    };
+}
+export declare const defaultPage: {
+    meta: {
+        category: string;
+        title: string;
+        description: string;
+        keyword: string;
+        searchIntent: string;
+    };
+    header: {
+        title: string;
+        content: string;
+    };
+    footer: {
+        content: {
+            title: string;
+            paragraph: never[];
+        };
+    };
+    sections: never[];
+    image: {
+        thumbnail: string;
+        original: string;
+        original_width: number;
+        original_height: number;
+        alt: string;
+    };
+    gallery: {
+        title: string;
+        description: string;
+        slides: never[];
+    };
+};
+export {};