@llmnative/react 0.1.0

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

@@ -0,0 +1,134 @@
+import { Prompt, PROMPTS } from "../../conf/Prompt";
+import { type ProviderConfigurationState } from "../ProviderConfiguration";
+import { PromptVariables } from "../../conf/Prompt";
+export default function fetchAI(provider?: string): (prompt: string, options?: {
+    model?: string;
+    temperature?: number;
+}, strategy?: keyof typeof PROMPTS | undefined) => Promise<any>;
+interface AIProvider {
+    name: string;
+    url: string;
+    model: string;
+    models: string[];
+    framework?: string;
+    frameworks?: string[];
+    temperature: number;
+    parseHeaders: () => Record<string, string>;
+    parseBody: (prompt: string, role: string, options: AIOptions) => Record<string, any>;
+    parseResponse: (response: any) => any;
+}
+interface AIOptions {
+    language?: string;
+    voice?: string;
+    style?: string;
+    role?: string;
+    model?: string;
+    temperature?: number;
+}
+export interface AIFetchConfig extends AIOptions {
+    provider?: keyof typeof PROVIDERS;
+}
+export declare const getAIProviderConfigurationState: (provider?: keyof typeof PROVIDERS) => ProviderConfigurationState;
+declare const PROVIDERS: {
+    openai: {
+        name: string;
+        url: string;
+        model: string;
+        models: string[];
+        framework: string;
+        frameworks: string[];
+        temperature: number;
+        parseHeaders: () => {
+            'Content-Type': string;
+            Authorization: string;
+        };
+        parseBody: (prompt: string, role: string, options: AIOptions) => {
+            model: string;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            temperature: number;
+        };
+        parseResponse: (response: any) => any;
+    };
+    gemini: {
+        name: string;
+        url: string;
+        model: string;
+        models: string[];
+        temperature: number;
+        parseHeaders: () => {
+            'Content-Type': string;
+            Authorization: string;
+        };
+        parseBody: (prompt: string, role: string, options: AIOptions) => {
+            model: string;
+            instances: {
+                content: string;
+            }[];
+            temperature: number;
+        };
+        parseResponse: (response: any) => any;
+    };
+    anthropic: {
+        name: string;
+        url: string;
+        model: string;
+        models: string[];
+        temperature: number;
+        parseHeaders: () => {
+            'Content-Type': string;
+            Authorization: string;
+        };
+        parseBody: (prompt: string, role: string, options: AIOptions) => {
+            model: string;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            temperature: number;
+        };
+        parseResponse: (response: any) => any;
+    };
+    mistral: {
+        name: string;
+        url: string;
+        model: string;
+        models: string[];
+        temperature: number;
+        parseHeaders: () => {
+            'Content-Type': string;
+            Authorization: string;
+        };
+        parseBody: (prompt: string, role: string, options: AIOptions) => {
+            model: string;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            temperature: number;
+        };
+        parseResponse: (response: any) => any;
+    };
+};
+export declare class AI extends Prompt {
+    config: AIProvider;
+    options: AIOptions;
+    data?: PromptVariables;
+    static fetch(prompt: string, config: AIFetchConfig, data?: PromptVariables): Promise<any>;
+    static getModels(provider?: keyof typeof PROVIDERS): string[];
+    constructor(provider?: keyof typeof PROVIDERS);
+    setOptions(options: AIOptions): this;
+    setData(data?: PromptVariables): this;
+    static defaults(): {
+        model: string;
+        role: string;
+        language: string;
+        country: string;
+        voice: string;
+        style: string;
+    };
+    fetchAPI(prompt: string): Promise<any>;
+}
+export {};

package/dist/types/src/providers/auth/AuthProvider.d.ts

@@ -0,0 +1,22 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface UserProfile {
+    uid?: string;
+    email?: string;
+    displayName?: string;
+    photoURL?: string;
+    [key: string]: any;
+}
+export type AuthIntent = 'signIn' | 'connect' | 'signOut' | 'disconnect' | 'reauthorize';
+export interface AuthSignInOptions {
+    scopes?: string[];
+    intent?: AuthIntent;
+    [key: string]: any;
+}
+export interface AuthProviderAdapter extends ProviderConfigurable {
+    getUser(): UserProfile | null;
+    signIn?(options?: AuthSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken?(scopes?: string[]): Promise<string>;
+    isAuthenticated?(): boolean;
+}

package/dist/types/src/providers/auth/AuthProviderContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { AuthProviderAdapter } from './AuthProvider';
+type AuthProviderContextValue = {
+    registry: Record<string, AuthProviderAdapter>;
+    defaultKey: string;
+};
+declare const AuthProviderContext: React.Context<AuthProviderContextValue | null>;
+export declare const AuthProvider: ({ registry, defaultKey, children, }: AuthProviderContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useAuthProvider: (name?: string) => AuthProviderAdapter;
+export default AuthProviderContext;

package/dist/types/src/providers/auth/dropbox/DropboxAuthProvider.d.ts

@@ -0,0 +1,16 @@
+import type { DropboxConfig } from '../../../Config';
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+export declare const DROPBOX_AUTH_SERVER = "www.dropbox.com/oauth2";
+export declare class DropboxAuthProvider implements AuthProviderAdapter {
+    private readonly config;
+    constructor(config: DropboxConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    getUser(): UserProfile | null;
+    signIn(options?: AuthSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(): Promise<string>;
+    isAuthenticated(): boolean;
+}

package/dist/types/src/providers/auth/google/GoogleAuth.d.ts

@@ -0,0 +1,44 @@
+import React from "react";
+declare global {
+    interface Window {
+        google: {
+            accounts: {
+                id: {
+                    initialize: (options: any) => void;
+                    prompt: (callback?: () => void) => void;
+                    renderButton: (element: HTMLElement, options: any) => void;
+                    disableAutoSelect: () => void;
+                    revoke: (hint: string, callback?: () => void) => void;
+                };
+                oauth2: {
+                    initTokenClient: (config: {
+                        client_id: string;
+                        scope: string;
+                        callback: (response: TokenResponse) => void;
+                    }) => {
+                        requestAccessToken: () => void;
+                    };
+                    hasGrantedAllScopes?: (response: TokenResponse, ...scopes: string[]) => boolean;
+                };
+            };
+        };
+        handleGoogleSignIn: (response: {
+            credential: string;
+        }) => void;
+    }
+}
+interface GoogleAuthProps {
+    scope?: string;
+    iconLogout: string;
+    className?: string;
+    avatarClass?: string;
+}
+interface TokenResponse {
+    access_token: string;
+    expires_in: number;
+    scope: string;
+    token_type: string;
+}
+declare const GoogleAuth: ({ scope, iconLogout, className, avatarClass }: GoogleAuthProps) => React.JSX.Element;
+export declare const googleGetAccessToken: (scopes: string[]) => Promise<string>;
+export default GoogleAuth;

package/dist/types/src/providers/auth/google/GoogleAuthProvider.d.ts

@@ -0,0 +1,12 @@
+import { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+export declare class GoogleAuthProvider implements AuthProviderAdapter {
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    getUser(): UserProfile | null;
+    signIn(options?: AuthSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(scopes?: string[]): Promise<string>;
+    isAuthenticated(): boolean;
+}

package/dist/types/src/providers/auth/google/apis/auth.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Ottiene un access token valido da Google utilizzando un Service Account.
+ */
+export declare function getGoogleAccessToken(scope: string, userToImpersonate: string): Promise<string>;

package/dist/types/src/providers/auth/google/auth.d.ts

@@ -0,0 +1,3 @@
+import { GoogleConfig } from "../../../Config";
+export declare const authConfig: <K extends keyof GoogleConfig>(key: K) => GoogleConfig[K] | undefined;
+export declare const getGoogleCredential: () => import("firebase/auth").OAuthCredential | null;

package/dist/types/src/providers/data/DataProvider.d.ts

@@ -0,0 +1,58 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+type FieldMap = Record<string, any>;
+type RecordObject = Record<string, FieldMap>;
+export type RecordProps = FieldMap & {
+    _key?: string;
+    _index?: number;
+};
+export type RecordArray = Array<RecordProps>;
+type ScalarValue = string | number | boolean | null;
+type RangeValue = string | number | boolean;
+type ListValue = string[] | number[];
+export type OperatorValue = ScalarValue | ListValue;
+export type Condition = {
+    eq?: ScalarValue;
+    lt?: RangeValue;
+    lte?: RangeValue;
+    gt?: RangeValue;
+    gte?: RangeValue;
+    nin?: ListValue;
+    in?: ListValue;
+};
+export type WhereClause = {
+    [field: string]: Condition | OperatorValue;
+};
+export type OrderClause = {
+    [field: string]: "asc" | "desc";
+};
+export interface DatabaseOptions {
+    where?: WhereClause;
+    order?: OrderClause;
+    fieldMap?: Record<string, string>;
+    onLoad?: (data: RecordObject) => RecordObject;
+}
+export interface DBConfig extends DatabaseOptions {
+    path?: string;
+}
+export interface ReadOptions {
+    where?: WhereClause;
+    order?: OrderClause;
+    toArray?: boolean;
+    exception?: boolean;
+}
+export interface SetChunksOptions {
+    chunkSize?: number;
+    purge?: boolean;
+    onProgress?: (done: number, total: number, message: string) => void;
+}
+export interface DataProviderAdapter extends ProviderConfigurable {
+    read(path: string, options?: ReadOptions): Promise<any>;
+    set(path: string, data: object, exception?: boolean): Promise<void>;
+    update(path: string, data: object, exception?: boolean): Promise<void>;
+    remove(path: string, exception?: boolean): Promise<void>;
+    subscribe(path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions): () => void;
+    count?(path: string): Promise<number>;
+    readShallow?(path: string, exception?: boolean): Promise<string[]>;
+    setChunks?(path: string, data: object, options?: SetChunksOptions): Promise<void>;
+}
+export {};

package/dist/types/src/providers/data/DataProviderContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { DataProviderAdapter } from './DataProvider';
+type DataProviderContextValue = {
+    registry: Record<string, DataProviderAdapter>;
+    defaultKey: string;
+};
+declare const DataProviderContext: React.Context<DataProviderContextValue | null>;
+export declare const DataProvider: ({ registry, defaultKey, children, }: DataProviderContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useDataProvider: (name?: string) => DataProviderAdapter;
+export default DataProviderContext;

package/dist/types/src/providers/data/firebase.d.ts

@@ -0,0 +1,21 @@
+import 'firebase/compat/database';
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from "./DataProvider";
+import type { ProviderConfigurationState } from "../ProviderConfiguration";
+export declare const SYSTEM_FIELDS: {
+    key: string;
+    value: string;
+};
+export declare class FirebaseDataProvider implements DataProviderAdapter {
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    readShallow: (path: string, exception?: boolean) => Promise<string[]>;
+    read: (path: string, { where, order, toArray, exception }?: ReadOptions) => Promise<any>;
+    update: (path: string, data: any, exception?: boolean) => Promise<void>;
+    set: (path: string, data: any, exception?: boolean) => Promise<void>;
+    setChunks: (path: string, data: any, { chunkSize, purge, onProgress }?: SetChunksOptions) => Promise<void>;
+    remove: (path: string, exception?: boolean) => Promise<void>;
+    count: (path: string) => Promise<number>;
+    subscribe: <T extends RecordProps = RecordProps>(path: string | undefined, setRecords: (records: T[]) => void, { where, order, fieldMap, onLoad }?: DatabaseOptions) => (() => void);
+}
+declare const _default: FirebaseDataProvider;
+export default _default;

package/dist/types/src/providers/data/mock.d.ts

@@ -0,0 +1,20 @@
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from './DataProvider';
+type CollectionStore = Record<string, Record<string, any>>;
+export declare class MockDataProvider implements DataProviderAdapter {
+    private store;
+    private listeners;
+    constructor(initialData?: CollectionStore);
+    isConfigured(): boolean;
+    getConfigurationState(): {
+        configured: boolean;
+    };
+    private getCollection;
+    private resolvePath;
+    private notify;
+    read: (path: string, options?: ReadOptions) => Promise<any>;
+    set: (path: string, data: object) => Promise<void>;
+    update: (path: string, data: object) => Promise<void>;
+    remove: (path: string) => Promise<void>;
+    subscribe: (path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions) => (() => void);
+}
+export {};

package/dist/types/src/providers/data/supabase.d.ts

@@ -0,0 +1,19 @@
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from "./DataProvider";
+import { type ProviderConfigurationState } from "../ProviderConfiguration";
+interface SupabaseConfig {
+    url: string;
+    anonKey: string;
+}
+export declare class SupabaseDataProvider implements DataProviderAdapter {
+    private config;
+    constructor(config: SupabaseConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    read: (path: string, _options?: ReadOptions) => Promise<any>;
+    set: (path: string, data: object) => Promise<void>;
+    update: (path: string, data: object) => Promise<void>;
+    remove: (path: string) => Promise<void>;
+    subscribe: (path: string | undefined, setRecords: (records: RecordArray) => void, _options?: DatabaseOptions) => (() => void);
+    count: (path: string) => Promise<number>;
+}
+export {};

package/dist/types/src/providers/email/EmailProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface EmailSendParams {
+    to: string | string[];
+    bcc?: string | string[];
+    subject: string;
+    message: string;
+}
+export interface EmailProviderAdapter extends ProviderConfigurable {
+    send(params: EmailSendParams): Promise<void>;
+}

package/dist/types/src/providers/email/EmailProviderContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { EmailProviderAdapter } from './EmailProvider';
+type EmailProviderContextValue = {
+    registry: Record<string, EmailProviderAdapter>;
+    defaultKey: string;
+};
+declare const EmailProviderContext: React.Context<EmailProviderContextValue | null>;
+export declare const EmailProvider: ({ registry, defaultKey, children, }: EmailProviderContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useEmailProvider: (name?: string) => EmailProviderAdapter | null;
+export default EmailProviderContext;

package/dist/types/src/providers/email/google/GmailEmailProvider.d.ts

@@ -0,0 +1,7 @@
+import { EmailProviderAdapter, EmailSendParams } from '../EmailProvider';
+import { type ProviderConfigurationState } from '../../ProviderConfiguration';
+export declare class GmailEmailProvider implements EmailProviderAdapter {
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    send(params: EmailSendParams): Promise<void>;
+}

package/dist/types/src/providers/email/google/apis/email.d.ts

@@ -0,0 +1,7 @@
+interface SendEmailOptions {
+    to: string;
+    subject: string;
+    message: string;
+}
+export declare function sendEmail({ to, subject, message }: SendEmailOptions): Promise<import("googleapis").gmail_v1.Schema$Message>;
+export {};

package/dist/types/src/providers/email/google/email.d.ts

@@ -0,0 +1,13 @@
+type SendEmailParams = {
+    to: string[];
+    bcc?: string[];
+    subject: string;
+    message: string;
+};
+type GmailSendResponse = {
+    id: string;
+    threadId: string;
+    labelIds?: string[];
+};
+export declare function sendEmail({ to, bcc, subject, message }: SendEmailParams): Promise<GmailSendResponse>;
+export {};

package/dist/types/src/providers/firebase-init.d.ts

@@ -0,0 +1,10 @@
+import firebase from "firebase/compat/app";
+import 'firebase/compat/database';
+import { Auth } from "firebase/auth";
+import { FirebaseConfig } from "../Config";
+import { type ProviderConfigurationState } from "./ProviderConfiguration";
+export declare const setFirebaseConfigState: (config: FirebaseConfig | undefined) => void;
+export declare const getFirebaseConfigurationState: () => ProviderConfigurationState;
+export declare const getSafeAuth: () => Auth | null;
+declare const init: (config: FirebaseConfig) => Promise<firebase.app.App>;
+export default init;

package/dist/types/src/providers/icon/IconProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface IconComponentProps {
+    size?: number;
+    className?: string;
+    [key: string]: unknown;
+}
+export interface IconProviderAdapter {
+    readonly id: string;
+    resolve(name: string): React.ComponentType<IconComponentProps> | null;
+}

package/dist/types/src/providers/icon/IconProviderContext.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { IconProviderAdapter } from './IconProvider';
+/** Built-in icon provider identifiers. */
+export type BuiltInIconProviderId = 'lucide' | 'phosphor';
+/**
+ * Configuration for the icon provider.
+ *
+ * - `BuiltInIconProviderId` string: selects a built-in provider (`'lucide'` | `'phosphor'`)
+ * - `IconProviderAdapter` instance: use a custom provider directly
+ * - object `{ provider, aliases? }`: custom provider with optional icon name aliases
+ *
+ * @example
+ * iconProvider="phosphor"
+ *
+ * @example
+ * iconProvider={new HeroIconProvider()}
+ *
+ * @example
+ * iconProvider={{ provider: new HeroIconProvider(), aliases: { delete: 'trash', edit: 'pencil' } }}
+ */
+export type AppIconProviderConfig = BuiltInIconProviderId | IconProviderAdapter | {
+    /** The icon provider instance to use. */
+    provider: IconProviderAdapter;
+    /** Map icon name aliases to actual icon names in this provider (`{ delete: 'trash' }`). */
+    aliases?: Record<string, string>;
+} | {
+    /** ID of the default provider to activate. Must be a key in `providers` or a built-in id. */
+    default: string;
+    /** Additional providers to register alongside the built-in ones. */
+    providers: Record<string, IconProviderAdapter>;
+    /** Map icon name aliases to actual icon names (`{ delete: 'trash' }`). */
+    aliases?: Record<string, string>;
+};
+export interface IconController {
+    providerId: string;
+    providers: Record<string, IconProviderAdapter>;
+    aliases: Record<string, string>;
+    setProvider: (id: string) => void;
+    registerProvider: (id: string, provider: IconProviderAdapter) => void;
+    resolve: IconProviderAdapter['resolve'];
+}
+export declare function IconProvider({ provider, config, children, }: {
+    provider?: IconProviderAdapter;
+    config?: AppIconProviderConfig;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useIconProvider(): IconProviderAdapter | null;
+export declare function useIconController(): IconController;

package/dist/types/src/providers/icon/LucideIconProvider.d.ts

@@ -0,0 +1,5 @@
+import type { IconProviderAdapter, IconComponentProps } from './IconProvider';
+export declare class LucideIconProvider implements IconProviderAdapter {
+    readonly id: "lucide";
+    resolve(name: string): import('react').ComponentType<IconComponentProps> | null;
+}

package/dist/types/src/providers/icon/PhosphorIconProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IconProviderAdapter, IconComponentProps } from './IconProvider';
+export type PhosphorWeight = 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';
+export declare class PhosphorIconProvider implements IconProviderAdapter {
+    private readonly weight;
+    readonly id: "phosphor";
+    private readonly _cache;
+    constructor(weight?: PhosphorWeight);
+    resolve(name: string): React.ComponentType<IconComponentProps> | null;
+}

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

@@ -0,0 +1,6 @@
+export type { IconProviderAdapter, IconComponentProps } from './IconProvider';
+export { LucideIconProvider } from './LucideIconProvider';
+export { PhosphorIconProvider } from './PhosphorIconProvider';
+export type { PhosphorWeight } from './PhosphorIconProvider';
+export { IconProvider, useIconProvider, useIconController } from './IconProviderContext';
+export type { AppIconProviderConfig, IconController } from './IconProviderContext';

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

@@ -0,0 +1,42 @@
+import { MockDataProvider } from './data/mock';
+import type { DataProviderAdapter } from './data/DataProvider';
+import type { StorageProviderAdapter } from './storage/StorageProvider';
+import type { AuthProviderAdapter } from './auth/AuthProvider';
+import type { EmailProviderAdapter } from './email/EmailProvider';
+import type { DropboxConfig, FirebaseConfig, GoogleOAuth2, GoogleServiceAccount } from '../Config';
+export type ServiceCategory = 'data' | 'storage' | 'auth' | 'email';
+type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailProviderAdapter;
+export interface DriverDescriptor<TConfig = unknown> {
+    service: ServiceCategory;
+    create: (config: TConfig) => AnyAdapter;
+}
+export type DriverManifest<TConfig> = Record<string, DriverDescriptor<TConfig>>;
+export type GoogleProviderConfig = GoogleOAuth2 & {
+    serviceAccount?: GoogleServiceAccount;
+    developerToken?: string;
+};
+export type SupabaseProviderConfig = {
+    url: string;
+    anonKey: string;
+    bucket?: string;
+};
+export type MockProviderConfig = {
+    data?: ConstructorParameters<typeof MockDataProvider>[0];
+};
+export declare const FIREBASE_MANIFEST: DriverManifest<FirebaseConfig>;
+export declare const GOOGLE_MANIFEST: DriverManifest<GoogleProviderConfig>;
+export declare const DROPBOX_MANIFEST: DriverManifest<DropboxConfig>;
+export declare const SUPABASE_MANIFEST: DriverManifest<SupabaseProviderConfig>;
+export declare const MOCK_MANIFEST: DriverManifest<MockProviderConfig>;
+export declare const PROVIDER_MANIFESTS: Record<string, DriverManifest<any>>;
+export type DataDriverName = 'dbRealtime' | 'supabaseDb' | 'mock';
+export type StorageDriverName = 'firestorage' | 'supabaseStorage';
+export type AuthDriverName = 'googleAuth' | 'dropboxAuth';
+export type EmailDriverName = 'gmail';
+export type ServicesConfig = {
+    data?: DataDriverName;
+    storage?: StorageDriverName;
+    auth?: AuthDriverName;
+    email?: EmailDriverName;
+};
+export {};

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

@@ -0,0 +1,10 @@
+declare const fetchScrape: (caller?: any, storePaths?: string[]) => {
+    googleSearch: (search: string) => Promise<any>;
+    googleImages: (search: string) => Promise<any>;
+    googleAutocomplete: (search: string) => Promise<any>;
+    googleTrends: (search: string) => Promise<any>;
+    googleMaps: (search: string) => Promise<any>;
+    googleMapsPhotos: (search: string) => Promise<any>;
+    googleMapsReviews: (search: string) => Promise<any>;
+};
+export default fetchScrape;

package/dist/types/src/providers/seo/google/keyword.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_GEO_TARGET = "geoTargetConstants/2380";
+export declare const DEFAULT_LANGUAGE = "languageConstants/1000";
+export declare const GEO_TARGETS: Record<string, string>;
+export declare const LANGUAGE_TARGETS: Record<string, string>;
+export declare function getGeoTargetConstant(code: string): string;
+export declare function getLanguageConstant(code: string): string;
+type GetKeywordIdeasParams = {
+    keyword: string;
+    googleAdsAccountId: string;
+    geoCode?: string;
+    languageCode?: string;
+};
+export declare function getKeywordIdeas({ keyword, googleAdsAccountId, geoCode, languageCode, }: GetKeywordIdeasParams): Promise<any>;
+export {};

package/dist/types/src/providers/seo/google/trend.d.ts

@@ -0,0 +1,25 @@
+export type TrendPoint = {
+    date: string;
+    value: number;
+};
+export type RelatedQuery = {
+    query: string;
+    value: number;
+};
+export type GoogleTrendsResponse = {
+    keyword: string;
+    timeline: TrendPoint[];
+};
+export type GoogleTrendsRelatedResponse = {
+    keyword: string;
+    top: RelatedQuery[];
+    rising: RelatedQuery[];
+};
+/**
+ * Ottiene i dati storici di trend per una keyword.
+ */
+export declare function getGoogleTrendsData(keyword: string, geo?: string, timeRange?: string): Promise<GoogleTrendsResponse>;
+/**
+ * Ottiene query correlate (top e rising) per una keyword.
+ */
+export declare function getGoogleTrendsRelated(keyword: string, geo?: string, timeRange?: string): Promise<GoogleTrendsRelatedResponse>;

package/dist/types/src/providers/storage/StorageProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface StorageProviderAdapter extends ProviderConfigurable {
+    upload(file: string, path: string): Promise<string | undefined>;
+    getURL(path: string): Promise<string | undefined>;
+    download(path: string): Promise<Blob | undefined>;
+    delete(path: string): Promise<boolean>;
+}