@llmnative/react 0.1.1 → 1.1.0

package/dist/types/src/providers/auth/firebase/FirebaseAuthProvider.d.ts

@@ -0,0 +1,49 @@
+import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+import type { FirebaseConfig } from '../../../Config';
+/**
+ * Firebase-specific sign-in options.
+ *
+ * method: 'password' (default) | 'anonymous' | 'oauth'
+ * email + password: required when method = 'password'
+ * provider: required when method = 'oauth' - e.g. 'github', 'apple', 'microsoft'
+ *           Note: for Google OAuth use GoogleAuthProvider, not FirebaseAuthProvider.
+ */
+export interface FirebaseSignInOptions extends AuthSignInOptions {
+    method?: 'password' | 'anonymous' | 'oauth';
+    email?: string;
+    password?: string;
+    provider?: string;
+}
+export interface FirebaseAuthProviderOptions {
+    /**
+     * Static config for this provider's own Firebase app. Omit when relying on
+     * another consumer (e.g. providers.firebase + FirebaseDataProvider, or the
+     * tenant-switching session factories in ProviderSession.tsx) to have already
+     * initialized the target app — matches the provider's original zero-arg behavior.
+     */
+    config?: FirebaseConfig;
+    /**
+     * Firebase app name this provider's session lives under. Defaults to the SDK's
+     * unnamed default app. Give this a dedicated name (e.g. 'control-plane') when a
+     * long-lived login session must coexist with the default app used by tenant
+     * switching — ProviderSession's 'data'/'storage' firebase factories reinitialize
+     * the default app on every switch, which would otherwise tear down this session.
+     */
+    appName?: string;
+}
+export declare class FirebaseAuthProvider implements AuthProviderAdapter {
+    private readonly options;
+    private readonly appName?;
+    private readonly initPromise;
+    constructor(options?: FirebaseAuthProviderOptions);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    getUser(): UserProfile | null;
+    isAuthenticated(): boolean;
+    signIn(options?: FirebaseSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(): Promise<string>;
+    getIdTokenClaims(): Promise<Record<string, unknown> | null>;
+}

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

@@ -4,9 +4,9 @@ declare global {
         google: {
             accounts: {
                 id: {
-                    initialize: (options: any) => void;
+                    initialize: (options: Record<string, unknown>) => void;
                     prompt: (callback?: () => void) => void;
-                    renderButton: (element: HTMLElement, options: any) => void;
+                    renderButton: (element: HTMLElement, options: Record<string, unknown>) => void;
                     disableAutoSelect: () => void;
                     revoke: (hint: string, callback?: () => void) => void;
                 };

package/dist/types/src/providers/auth/supabase/SupabaseAuthProvider.d.ts

@@ -0,0 +1,48 @@
+import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+export interface SupabaseAuthConfig {
+    url: string;
+    anonKey: string;
+}
+/**
+ * Supabase-specific sign-in options.
+ * Passed as part of `AuthSignInOptions` (open `[key: string]: any` index signature).
+ *
+ * method:   'password' (default) | 'magic_link' | 'oauth' | 'anonymous'
+ * email:    required for 'password' and 'magic_link'
+ * password: required for 'password'
+ * provider: required for 'oauth' - e.g. 'github', 'google', 'apple', 'twitter'
+ * redirectTo: optional - overrides the redirect URL after OAuth / magic link
+ */
+export interface SupabaseSignInOptions extends AuthSignInOptions {
+    method?: 'password' | 'magic_link' | 'oauth' | 'anonymous';
+    email?: string;
+    password?: string;
+    provider?: string;
+    redirectTo?: string;
+}
+export declare class SupabaseAuthProvider implements AuthProviderAdapter {
+    private config;
+    private get client();
+    constructor(config: SupabaseAuthConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    /**
+     * Returns the currently cached session user (synchronous, no network call).
+     * Returns null if no active session.
+     */
+    getUser(): UserProfile | null;
+    isAuthenticated(): boolean;
+    /**
+     * Authenticate with Supabase.
+     *
+     * options.method = 'password'   (default): email + password sign-in
+     * options.method = 'magic_link': OTP email - returns null (email sent, no user yet)
+     * options.method = 'oauth':      redirect flow - returns null (user arrives after redirect)
+     * options.method = 'anonymous':  anonymous session
+     */
+    signIn(options?: SupabaseSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(): Promise<string>;
+}

package/dist/types/src/providers/credentials/CredentialsProvider.d.ts

@@ -0,0 +1,3 @@
+export interface CredentialsAdapter {
+    getToken(scope?: string): Promise<string>;
+}

package/dist/types/src/providers/credentials/CredentialsProviderContext.d.ts

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

package/dist/types/src/providers/credentials/google/GoogleServiceAccountProvider.d.ts

@@ -0,0 +1,8 @@
+import type { CredentialsAdapter } from '../CredentialsProvider';
+import type { GoogleServiceAccount } from '../../../Config';
+export declare class GoogleServiceAccountProvider implements CredentialsAdapter {
+    private config;
+    private cache;
+    constructor(config: GoogleServiceAccount);
+    getToken(scope?: string): Promise<string>;
+}

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

@@ -1,10 +1,20 @@
 import type { ProviderConfigurable } from '../ProviderConfiguration';
-type FieldMap = Record<string, any>;
+/** Canonical primary-key field name used by all data providers and the Form widget. */
+export declare const RECORD_KEY: "_key";
+/** A single field value in a record - scalar, nested object, or array of scalars. */
+export type FieldValue = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
+type FieldMap = Record<string, FieldValue>;
 type RecordObject = Record<string, FieldMap>;
+/**
+ * A data record as used by Form, Grid, and all data providers.
+ * `_key` is the primary key injected by the provider (matches `RECORD_KEY`).
+ * `_index` is the 0-based position in the parent collection (read-only, injected by providers).
+ */
 export type RecordProps = FieldMap & {
     _key?: string;
     _index?: number;
 };
+/** Ordered list of records returned by a provider `subscribe` or `read` call. */
 export type RecordArray = Array<RecordProps>;
 type ScalarValue = string | number | boolean | null;
 type RangeValue = string | number | boolean;
@@ -45,14 +55,30 @@ export interface SetChunksOptions {
     purge?: boolean;
     onProgress?: (done: number, total: number, message: string) => void;
 }
+/**
+ * Port contract for all data back-ends (Firebase RTDB, Firestore, Supabase, Mock, …).
+ * Implement this interface to register a custom provider via `<App providers={...}>`.
+ */
 export interface DataProviderAdapter extends ProviderConfigurable {
+    /** Read a single record or collection at `path`. Returns `null` when not found. */
     read(path: string, options?: ReadOptions): Promise<any>;
+    /** Write (overwrite) the node at `path` with `data`. */
     set(path: string, data: object, exception?: boolean): Promise<void>;
+    /** Merge `data` into the existing node at `path` (partial update). */
     update(path: string, data: object, exception?: boolean): Promise<void>;
+    /** Delete the node at `path`. */
     remove(path: string, exception?: boolean): Promise<void>;
+    /**
+     * Subscribe to real-time updates at `path`.
+     * `setRecords` is called immediately with the current data, then on every change.
+     * Returns a cleanup function that cancels the subscription.
+     */
     subscribe(path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions): () => void;
+    /** Return the number of records in the collection at `path`. */
     count?(path: string): Promise<number>;
+    /** Return only the direct child keys of `path` without fetching full records. */
     readShallow?(path: string, exception?: boolean): Promise<string[]>;
+    /** Write `data` to `path` in batches (useful for large imports). */
     setChunks?(path: string, data: object, options?: SetChunksOptions): Promise<void>;
 }
 export {};

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

@@ -1,4 +1,3 @@
-import 'firebase/compat/database';
 import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from "./DataProvider";
 import type { ProviderConfigurationState } from "../ProviderConfiguration";
 export declare const SYSTEM_FIELDS: {
@@ -6,13 +5,15 @@ export declare const SYSTEM_FIELDS: {
     value: string;
 };
 export declare class FirebaseDataProvider implements DataProviderAdapter {
+    private static listenerRegistered;
+    constructor();
     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>;
+    update: (path: string, data: object, exception?: boolean) => Promise<void>;
+    set: (path: string, data: object, exception?: boolean) => Promise<void>;
+    setChunks: (path: string, data: object, { 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);

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

@@ -0,0 +1,45 @@
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from './DataProvider';
+import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export interface FirestoreDataProviderConfig {
+    /** Named database within the current app's project — omit for the "(default)" database. */
+    databaseId?: string;
+}
+export declare class FirestoreDataProvider implements DataProviderAdapter {
+    private static listenerRegistered;
+    private databaseId?;
+    constructor(config?: FirestoreDataProviderConfig);
+    /** Same "(default)" database as before when no databaseId was configured. */
+    private getDb;
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    read: (path: string, { where, order, toArray, exception }?: 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>;
+    count: (path: string) => Promise<number>;
+    /**
+     * Real-time listener via Firestore onSnapshot.
+     *
+     * - Collection path (/users): subscribes to all matching documents.
+     * - Document path (/users/uid): subscribes to a single document.
+     *
+     * Returns an unsubscribe function - always call it on component unmount.
+     *
+     * Firestore inequality filters on a field require the first orderBy() to be
+     * on that same field. Pass `order` accordingly to avoid SDK errors.
+     */
+    subscribe: <T extends RecordProps = RecordProps>(path: string | undefined, setRecords: (records: T[]) => void, { where, order, fieldMap, onLoad }?: DatabaseOptions) => (() => void);
+    /**
+     * Returns the list of document IDs in a collection without loading document
+     * data - the Firestore equivalent of RTDB's ?shallow=true REST endpoint.
+     * On a document path, returns the document's field names.
+     */
+    readShallow: (path: string, exception?: boolean) => Promise<string[]>;
+    /**
+     * Bulk-writes `data` to a collection using Firestore writeBatch.
+     * Each batch holds at most min(chunkSize, 500) documents (Firestore limit).
+     * If `purge` is true, all existing documents in the collection are deleted
+     * first (also in batches of 500).
+     */
+    setChunks: (path: string, data: object, { chunkSize, purge, onProgress }?: SetChunksOptions) => Promise<void>;
+}

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

@@ -1,9 +1,16 @@
 import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from './DataProvider';
 type CollectionStore = Record<string, Record<string, any>>;
+export type MockDataProviderOptions = {
+    persist?: boolean;
+    storageKey?: string;
+};
 export declare class MockDataProvider implements DataProviderAdapter {
     private store;
     private listeners;
-    constructor(initialData?: CollectionStore);
+    private persistKey;
+    constructor(initialData?: CollectionStore, options?: MockDataProviderOptions);
+    private loadStore;
+    private saveStore;
     isConfigured(): boolean;
     getConfigurationState(): {
         configured: boolean;

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

@@ -1,19 +1,45 @@
-import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from "./DataProvider";
-import { type ProviderConfigurationState } from "../ProviderConfiguration";
-interface SupabaseConfig {
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordArray } from './DataProvider';
+import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export interface SupabaseDataConfig {
     url: string;
     anonKey: string;
+    /**
+     * Name of the primary-key column in every Supabase table.
+     * Default: 'id'. Must be a text/uuid column.
+     */
+    primaryKey?: string;
+    /**
+     * Tenant-session JWT signed by the control-plane, scoped to this project.
+     * When present, the adapter uses an uncached, disposable client with this
+     * bearer token instead of the shared single-project client — see
+     * createSupabaseClient() in supabase-init.ts.
+     */
+    accessToken?: string;
 }
 export declare class SupabaseDataProvider implements DataProviderAdapter {
     private config;
-    constructor(config: SupabaseConfig);
+    private get pk();
+    private scopedClient;
+    private get client();
+    constructor(config: SupabaseDataConfig);
+    /** Force-closes any realtime channels left open before this adapter is discarded. No-op for the shared (non-scoped) client. */
+    dispose: () => Promise<void>;
     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);
+    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>;
+    /**
+     * Real-time subscription via Supabase Postgres Changes.
+     * Requires the table to have Realtime enabled in the Supabase dashboard.
+     * Falls back gracefully if the channel cannot be created.
+     */
+    subscribe: (path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions) => (() => void);
     count: (path: string) => Promise<number>;
+    /**
+     * Writes a large dataset in batches.
+     * If opts.purge = true, deletes all existing rows before writing.
+     */
+    setChunks: (path: string, data: object, opts?: SetChunksOptions) => Promise<void>;
 }
-export {};

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

@@ -0,0 +1,3 @@
+import type { ProviderDescriptor } from '../ProviderDescriptor';
+export type EmailProviderId = 'resend' | 'sendgrid' | 'mailgun' | 'postmark' | 'ses' | 'smtp';
+export declare const EMAIL_PROVIDER_DEFINITIONS: ProviderDescriptor[];

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

@@ -1,10 +1,27 @@
-import firebase from "firebase/compat/app";
-import 'firebase/compat/database';
-import { Auth } from "firebase/auth";
+import { type FirebaseApp } from 'firebase/app';
+import { type 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 declare const setFirebaseConfigState: (config: FirebaseConfig | undefined, appName?: string) => void;
+export declare const getFirebaseConfigurationState: (appName?: string) => ProviderConfigurationState;
+export declare const getFirestoreConfigurationState: (appName?: string) => ProviderConfigurationState;
+export declare const getSafeAuth: (appName?: string) => Auth | null;
+export declare const getFirebaseAuthorization: () => Promise<boolean>;
+/**
+ * Signs into the currently-initialized Firebase app using a custom token minted
+ * server-side (Admin SDK createCustomToken()) and scoped to a specific project —
+ * the multi-tenant session-switch path, distinct from the Google-login flow above.
+ *
+ * Forces in-memory persistence: this session must never survive a reload or be
+ * written to IndexedDB/localStorage by the SDK's default persistence behavior.
+ * Call init(config) to point the app at the right project *before* calling this.
+ */
+export declare const signInWithFirebaseCustomToken: (token: string) => Promise<boolean>;
+declare const init: (config: FirebaseConfig, appName?: string) => Promise<FirebaseApp>;
+/**
+ * Invokes a Firebase Callable Function against a given app (the SDK auto-attaches
+ * that app's current auth session's ID token — no manual header wiring). Lazily
+ * imports 'firebase/functions' so it's not bundled for apps that never call one.
+ */
+export declare function callFirebaseFunction<T = unknown>(functionName: string, data: unknown, appName?: string, region?: string): Promise<T>;
 export default init;

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

@@ -2,7 +2,7 @@ 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;
+    weight: PhosphorWeight;
     readonly id: "phosphor";
     private readonly _cache;
     constructor(weight?: PhosphorWeight);

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

@@ -1,25 +1,26 @@
+import type { CredentialsAdapter } from './credentials/CredentialsProvider';
 import { MockDataProvider } from './data/mock';
+import type { AIProviderAdapter } from './ai/AIProvider';
 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;
+import type { AIConfig, DropboxConfig, FirebaseConfig, GoogleOAuth2, GoogleServiceAccount, SupabaseConfig } from '../Config';
+import type { ProviderService } from './ProviderRegistryContext';
+/** The 6 built-in categories — alias of ProviderService (ProviderRegistryContext.tsx), derived from ProviderAdapterMap so the two can't drift. */
+export type ServiceCategory = ProviderService;
+type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailProviderAdapter | AIProviderAdapter | CredentialsAdapter;
 export interface DriverDescriptor<TConfig = unknown> {
     service: ServiceCategory;
     create: (config: TConfig) => AnyAdapter;
+    when?: (config: TConfig) => boolean;
 }
 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 SupabaseProviderConfig = SupabaseConfig;
 export type MockProviderConfig = {
     data?: ConstructorParameters<typeof MockDataProvider>[0];
 };
@@ -28,15 +29,20 @@ 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 AI_MANIFEST: DriverManifest<AIConfig>;
 export declare const PROVIDER_MANIFESTS: Record<string, DriverManifest<any>>;
-export type DataDriverName = 'dbRealtime' | 'supabaseDb' | 'mock';
+export type DataDriverName = 'dbRealtime' | 'firestoreDb' | 'supabaseDb' | 'mock';
 export type StorageDriverName = 'firestorage' | 'supabaseStorage';
-export type AuthDriverName = 'googleAuth' | 'dropboxAuth';
+export type AuthDriverName = 'googleAuth' | 'firebaseAuth' | 'dropboxAuth' | 'supabaseAuth';
 export type EmailDriverName = 'gmail';
+export type AIDriverName = 'openai' | 'openrouter' | 'opencode' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral';
+export type CredentialsDriverName = 'googleServiceAccount';
 export type ServicesConfig = {
-    data?: DataDriverName;
-    storage?: StorageDriverName;
-    auth?: AuthDriverName;
-    email?: EmailDriverName;
+    data?: DataDriverName | string;
+    storage?: StorageDriverName | string;
+    auth?: AuthDriverName | string;
+    email?: EmailDriverName | string;
+    ai?: AIDriverName | string;
+    credentials?: CredentialsDriverName | string;
 };
 export {};

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

@@ -0,0 +1,7 @@
+import type { ProxyConfig } from '../../Config';
+export declare const PROXY_CALLER_HEADER = "x-llmnative-proxy";
+export declare const DEFAULT_PROXY_ROUTE = "/api/proxy";
+export declare const configureProxy: (config?: ProxyConfig) => void;
+export declare const proxyFetch: typeof fetch;
+export declare const useProxy: () => typeof fetch;
+export declare const isProxyEnabled: () => boolean;

package/dist/types/src/providers/proxy/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare const PROXY_PATH = "/api/proxy";
+export declare const createProxyPlugin: (route?: string) => Plugin;

package/dist/types/src/providers/publish/PublishProvider.d.ts

@@ -0,0 +1,29 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface BuildManifest {
+    pages: number;
+    sizeBytes: number;
+    generatedAt: string;
+}
+export interface BuildArtifacts {
+    buildId: string;
+    outputPath: string;
+    manifest: BuildManifest;
+}
+export type DeployOptions = Record<string, never>;
+export interface DeployResult {
+    success: boolean;
+    buildId: string;
+    url?: string;
+    error?: string;
+}
+export interface Deployment {
+    buildId: string;
+    timestamp: string;
+    status: 'success' | 'failed' | 'in_progress';
+    url?: string;
+}
+export interface PublishProviderAdapter extends ProviderConfigurable {
+    deploy(artifacts: BuildArtifacts, options?: DeployOptions): Promise<DeployResult>;
+    rollback(buildId: string): Promise<DeployResult>;
+    getDeployments(limit?: number): Promise<Deployment[]>;
+}

package/dist/types/src/providers/publish/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderDescriptor } from '../ProviderDescriptor';
+export type PublishProviderId = 'cloudflare_pages' | 'firebase_hosting' | 'supabase_storage' | 'ftp' | 'sftp' | 'netlify' | 'github_pages' | 's3_cloudfront' | 'static_export';
+export declare const PUBLISH_PROVIDER_DEFINITIONS: ProviderDescriptor[];

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

@@ -1,4 +1,5 @@
-declare const fetchScrape: (caller?: any, storePaths?: string[]) => {
+import { DataProviderAdapter } from "../../providers/data/DataProvider";
+declare const fetchScrape: (dataProvider: DataProviderAdapter) => {
     googleSearch: (search: string) => Promise<any>;
     googleImages: (search: string) => Promise<any>;
     googleAutocomplete: (search: string) => Promise<any>;

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

@@ -10,5 +10,10 @@ type GetKeywordIdeasParams = {
     geoCode?: string;
     languageCode?: string;
 };
-export declare function getKeywordIdeas({ keyword, googleAdsAccountId, geoCode, languageCode, }: GetKeywordIdeasParams): Promise<any>;
+export declare function getKeywordIdeas({ keyword, googleAdsAccountId, geoCode, languageCode, }: GetKeywordIdeasParams): Promise<{
+    keyword: string | undefined;
+    avgMonthlySearches: number;
+    competition: string;
+    cpc: number | null;
+}[]>;
 export {};