@geenius/adapters 0.1.0 → 0.3.0

package/packages/shared/dist/index.d.mts

@@ -0,0 +1,625 @@
+interface AuthUser {
+    id: string;
+    email?: string;
+    name?: string;
+    image?: string;
+    role?: string;
+    createdAt?: string;
+}
+interface AuthSession {
+    userId: string;
+    token?: string;
+    expiresAt?: string;
+}
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    order?: 'asc' | 'desc';
+}
+type QueryOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains';
+interface QueryCondition {
+    field: string;
+    operator: QueryOperator;
+    value: unknown;
+}
+type QueryFilter = QueryCondition[];
+interface Plan {
+    id: string;
+    name: string;
+    price: number;
+    currency: string;
+    interval: 'month' | 'year' | 'one-time';
+    features: string[];
+}
+interface Subscription {
+    id: string;
+    userId: string;
+    planId: string;
+    status: 'active' | 'cancelled' | 'past_due' | 'trialing';
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+}
+interface CheckoutParams {
+    planId: string;
+    userId: string;
+    successUrl?: string;
+    cancelUrl?: string;
+}
+interface CheckoutResult {
+    url: string;
+    sessionId: string;
+}
+type ChatRole = 'system' | 'user' | 'assistant';
+interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
+interface AiOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface ChatResponse {
+    content: string;
+    finishReason: 'stop' | 'length' | 'error';
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface StoredFile {
+    id: string;
+    name: string;
+    path: string;
+    size: number;
+    mimeType: string;
+    url: string;
+    createdAt: string;
+}
+type AdapterDomain = 'db' | 'auth' | 'payments' | 'ai' | 'storage' | 'admin';
+interface DomainAdapterConfig {
+    provider: string;
+    apiKey?: string;
+    baseUrl?: string;
+    options?: Record<string, unknown>;
+}
+interface AdapterConfig {
+    db?: DomainAdapterConfig;
+    auth?: DomainAdapterConfig;
+    payments?: DomainAdapterConfig;
+    ai?: DomainAdapterConfig;
+    storage?: DomainAdapterConfig;
+    admin?: DomainAdapterConfig;
+}
+type AdapterStatusType = 'connected' | 'disconnected' | 'error' | 'initializing';
+interface AdapterStatusInfo {
+    domain: AdapterDomain;
+    provider: string;
+    status: AdapterStatusType;
+    latency?: number;
+    lastCheckedAt?: number;
+    error?: string;
+}
+interface AdapterRegistryEntry {
+    domain: AdapterDomain;
+    provider: string;
+    status: AdapterStatusType;
+    config: DomainAdapterConfig;
+    connectedAt?: number;
+}
+
+type DbErrorCode = 'NOT_FOUND' | 'CONSTRAINT_VIOLATION' | 'QUERY_ERROR' | 'CONNECTION_ERROR' | 'COLLECTION_NOT_CONFIGURED';
+type AuthErrorCode = 'INVALID_CREDENTIALS' | 'USER_EXISTS' | 'SESSION_EXPIRED' | 'UNAUTHORIZED' | 'OAUTH_ERROR' | 'SERVICE_ERROR';
+type AiErrorCode = 'MODEL_ERROR' | 'RATE_LIMIT' | 'CONTEXT_LENGTH' | 'SERVICE_ERROR' | 'EMBEDDING_ERROR';
+type StorageErrorCode = 'NOT_FOUND' | 'UPLOAD_FAILED' | 'DOWNLOAD_FAILED' | 'QUOTA_EXCEEDED' | 'INVALID_KEY' | 'SERVICE_ERROR';
+type PaymentsErrorCode = 'INVALID_PLAN' | 'CHECKOUT_FAILED' | 'SUBSCRIPTION_NOT_FOUND' | 'CANCEL_FAILED' | 'SERVICE_ERROR' | 'NOT_AVAILABLE';
+type AdminErrorCode = 'USER_NOT_FOUND' | 'OPERATION_FAILED' | 'SERVICE_ERROR';
+declare class AdapterError extends Error {
+    readonly domain: string;
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, domain: string, code: string, cause?: unknown | undefined);
+}
+declare class DbError extends AdapterError {
+    constructor(message: string, code: DbErrorCode, cause?: unknown);
+}
+declare class AuthError extends AdapterError {
+    constructor(message: string, code: AuthErrorCode, cause?: unknown);
+}
+declare class AiError extends AdapterError {
+    constructor(message: string, code: AiErrorCode, cause?: unknown);
+}
+declare class StorageError extends AdapterError {
+    constructor(message: string, code: StorageErrorCode, cause?: unknown);
+}
+declare class PaymentsError extends AdapterError {
+    constructor(message: string, code: PaymentsErrorCode, cause?: unknown);
+}
+declare class AdminError extends AdapterError {
+    constructor(message: string, code: AdminErrorCode, cause?: unknown);
+}
+declare function isAdapterError(error: unknown): error is AdapterError;
+declare function isRetryable(error: unknown): boolean;
+
+interface RetryOptions {
+    /** Maximum number of attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 500) */
+    delayMs?: number;
+    /** Backoff multiplier (default: 2) */
+    backoffMultiplier?: number;
+    /** Custom predicate to determine if error is retryable (default: isRetryable) */
+    shouldRetry?: (error: unknown) => boolean;
+}
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+/**
+ * Configure the adapter system.
+ * Call once at app startup before using any adapter hooks.
+ *
+ * @example
+ * ```ts
+ * configureAdapters({
+ *   db: { provider: 'convex' },
+ *   auth: { provider: 'better-auth' },
+ *   ai: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY },
+ *   storage: { provider: 'r2' },
+ *   payments: { provider: 'stripe' },
+ * })
+ * ```
+ */
+declare function configureAdapters(config: AdapterConfig): void;
+/**
+ * Get the current adapter configuration.
+ * Throws if configureAdapters() has not been called.
+ */
+declare function getAdapterConfig(): AdapterConfig;
+/**
+ * Check if adapters have been configured.
+ */
+declare function isAdaptersConfigured(): boolean;
+/**
+ * Reset adapter configuration (useful for testing).
+ */
+declare function resetAdapterConfig(): void;
+/**
+ * Get config for a specific adapter domain.
+ */
+declare function getDomainConfig(domain: AdapterDomain): DomainAdapterConfig | null;
+
+/** OAuth provider identifiers */
+type OAuthProvider = 'google' | 'github' | 'discord' | 'twitter' | 'apple' | 'microsoft' | string;
+/**
+ * Minimal auth adapter contract.
+ *
+ * This interface defines the core authentication operations that every provider
+ * must support. For rich auth features (MFA, passkeys, API keys, RBAC, session
+ * management, magic links, password reset), use `@geenius/auth` directly — it
+ * implements this interface and extends it with the full `AuthProviderAdapter`.
+ *
+ * @example
+ * ```ts
+ * import type { AuthAdapter } from '@geenius/adapters'
+ * import { createLocalStorageAuthAdapter } from '@geenius/adapters' // mock
+ * import { createAuthProvider } from '@geenius/auth'                // real
+ * ```
+ */
+interface AuthAdapter {
+    signIn(email: string, password: string): Promise<AuthSession>;
+    signUp(email: string, password: string, name?: string): Promise<AuthSession>;
+    /** Initiate an OAuth sign-in flow. Returns the redirect URL for the provider. */
+    signInWithOAuth(provider: OAuthProvider, options?: {
+        redirectUrl?: string;
+    }): Promise<{
+        url: string;
+    }>;
+    signOut(): Promise<void>;
+    getSession(): Promise<AuthSession | null>;
+    getUser(): Promise<AuthUser | null>;
+    updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null>;
+}
+
+interface DbAdapter {
+    create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>): Promise<T & {
+        id: string;
+    }>;
+    get<T>(collection: string, id: string): Promise<T | null>;
+    update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>): Promise<T | null>;
+    delete(collection: string, id: string): Promise<boolean>;
+    list<T>(collection: string, options?: ListOptions): Promise<T[]>;
+    query<T>(collection: string, filter: QueryFilter): Promise<T[]>;
+    count(collection: string, filter?: QueryFilter): Promise<number>;
+}
+
+/**
+ * Minimal AI adapter contract.
+ *
+ * This interface defines the core AI operations that every provider must support.
+ * For rich AI features (memory, skills, tool calling, content templates, streaming
+ * callbacks), use `@geenius/ai` directly — it implements this interface and extends
+ * it with the full feature set.
+ *
+ * @example
+ * ```ts
+ * import type { AiAdapter } from '@geenius/adapters'
+ * import { createLocalStorageAiAdapter } from '@geenius/adapters' // mock
+ * import { AIClient } from '@geenius/ai'                          // real
+ * ```
+ */
+interface AiAdapter {
+    chat(messages: ChatMessage[], options?: AiOptions): Promise<ChatResponse>;
+    complete(prompt: string, options?: AiOptions): Promise<string>;
+    embed(text: string | string[]): Promise<number[][]>;
+    /** Stream chat tokens as an async iterable of text deltas. */
+    stream(messages: ChatMessage[], options?: AiOptions): AsyncIterable<string>;
+}
+
+interface FileStorageAdapter {
+    upload(file: File | Blob, path: string, name?: string): Promise<StoredFile>;
+    download(fileId: string): Promise<Blob>;
+    delete(fileId: string): Promise<boolean>;
+    list(prefix?: string): Promise<StoredFile[]>;
+    getUrl(fileId: string): Promise<string>;
+}
+
+/**
+ * Minimal payments adapter contract.
+ *
+ * This interface defines the core payment operations that every provider must
+ * support. For rich payment features (webhooks, invoices, customer portal, plan
+ * sync, subscription updates, refunds), use `@geenius/payments` directly — it
+ * implements this interface and extends it with the full `PaymentProviderAdapter`.
+ *
+ * @example
+ * ```ts
+ * import type { PaymentsAdapter } from '@geenius/adapters'
+ * import { createLocalStoragePaymentsAdapter } from '@geenius/adapters' // mock
+ * import { createPaymentProvider } from '@geenius/payments'             // real
+ * ```
+ */
+interface PaymentsAdapter {
+    createCheckout(params: CheckoutParams): Promise<CheckoutResult>;
+    getSubscription(userId: string): Promise<Subscription | null>;
+    cancelSubscription(subscriptionId: string): Promise<void>;
+    getPlans(): Promise<Plan[]>;
+    isFeatureEnabled(userId: string, feature: string): Promise<boolean>;
+}
+
+interface AdminMetrics {
+    totalUsers: number;
+    activeUsers: number;
+    newUsersToday: number;
+    totalRevenue?: number;
+    mrr?: number;
+}
+interface ManagedUser extends AuthUser {
+    isActive: boolean;
+    isBanned: boolean;
+    plan?: string;
+    lastLoginAt?: string;
+}
+interface AdminAdapter {
+    /** List all users with pagination */
+    listUsers(options?: {
+        limit?: number;
+        offset?: number;
+        search?: string;
+    }): Promise<ManagedUser[]>;
+    /** Get a single user by ID */
+    getUser(id: string): Promise<ManagedUser | null>;
+    /** Ban a user */
+    banUser(id: string): Promise<boolean>;
+    /** Unban a user */
+    unbanUser(id: string): Promise<boolean>;
+    /** Delete a user */
+    deleteUser(id: string): Promise<boolean>;
+    /** Get dashboard metrics */
+    getMetrics(): Promise<AdminMetrics>;
+}
+
+type AdapterForDomain<D extends AdapterDomain> = D extends 'auth' ? AuthAdapter : D extends 'db' ? DbAdapter : D extends 'ai' ? AiAdapter : D extends 'storage' ? FileStorageAdapter : D extends 'payments' ? PaymentsAdapter : D extends 'admin' ? AdminAdapter : never;
+/**
+ * Register a factory function for a specific domain + provider combination.
+ *
+ * @example
+ * ```ts
+ * import { registerResolver, createConvexDbAdapter } from '@geenius/adapters-shared'
+ *
+ * registerResolver('db', 'convex', (config) =>
+ *   createConvexDbAdapter({ client: convex, functions: myFunctions })
+ * )
+ * ```
+ */
+declare function registerResolver<D extends AdapterDomain>(domain: D, provider: string, resolver: (config: DomainAdapterConfig) => AdapterForDomain<D>): void;
+/**
+ * Resolve an adapter for a given domain using the current config.
+ * Requires that configureAdapters() has been called and a resolver
+ * has been registered for the domain's provider.
+ *
+ * @example
+ * ```ts
+ * configureAdapters({ db: { provider: 'convex' } })
+ * const db = resolveAdapter('db') // returns the registered Convex adapter
+ * ```
+ */
+declare function resolveAdapter<D extends AdapterDomain>(domain: D): AdapterForDomain<D>;
+/**
+ * Check if a resolver is registered for a domain + provider.
+ */
+declare function hasResolver(domain: AdapterDomain, provider: string): boolean;
+/**
+ * Clear all registered resolvers (useful for testing).
+ */
+declare function clearResolvers(): void;
+
+declare const ADAPTER_DOMAINS: readonly AdapterDomain[];
+declare const DB_PROVIDERS: readonly ["localStorage", "convex", "supabase", "neon", "mongodb"];
+declare const AUTH_PROVIDERS: readonly ["localStorage", "better-auth", "convex-auth", "clerk", "supabase-auth"];
+declare const AI_PROVIDERS: readonly ["localStorage", "openai", "anthropic", "gemini", "ollama", "cloudflare-ai-gateway", "vercel-ai-sdk"];
+declare const STORAGE_PROVIDERS: readonly ["localStorage", "r2", "s3", "uploadthing", "supabase-storage", "convex-storage", "minio"];
+declare const PAYMENT_PROVIDERS: readonly ["localStorage", "stripe", "noop"];
+declare const ADMIN_PROVIDERS: readonly ["localStorage"];
+type DbProviderName = (typeof DB_PROVIDERS)[number];
+type AuthProviderName = (typeof AUTH_PROVIDERS)[number];
+type AiProviderName = (typeof AI_PROVIDERS)[number];
+type StorageProviderName = (typeof STORAGE_PROVIDERS)[number];
+type PaymentProviderName = (typeof PAYMENT_PROVIDERS)[number];
+type AdminProviderName = (typeof ADMIN_PROVIDERS)[number];
+declare const ADAPTER_STATUSES: readonly ["connected", "disconnected", "error", "initializing"];
+type AdapterStatus = (typeof ADAPTER_STATUSES)[number];
+declare const DOMAIN_LABELS: Record<AdapterDomain, string>;
+declare const DOMAIN_ICONS: Record<AdapterDomain, string>;
+declare const DOMAIN_DESCRIPTIONS: Record<AdapterDomain, string>;
+interface ProviderMeta {
+    id: string;
+    name: string;
+    domain: AdapterDomain;
+    description: string;
+    /** Minimum tier required to use this provider */
+    tier: 'pronto' | 'lancio' | 'studio';
+    docUrl?: string;
+}
+declare const PROVIDER_REGISTRY: ProviderMeta[];
+/**
+ * Get all providers for a specific domain.
+ */
+declare function getProvidersForDomain(domain: AdapterDomain): ProviderMeta[];
+/**
+ * Get a specific provider by id and domain.
+ */
+declare function getProviderMeta(domain: AdapterDomain, providerId: string): ProviderMeta | undefined;
+
+declare function createLocalStorageAuthAdapter(): AuthAdapter;
+
+declare function createLocalStorageDbAdapter(): DbAdapter;
+
+interface ConvexClient {
+    query: (fn: unknown, args?: Record<string, unknown>) => Promise<unknown>;
+    mutation: (fn: unknown, args?: Record<string, unknown>) => Promise<unknown>;
+}
+interface ConvexDbAdapterOptions {
+    /** Pre-configured Convex client */
+    client: ConvexClient;
+    /** Map of collection names to Convex function references */
+    functions: {
+        [collection: string]: {
+            create?: unknown;
+            get?: unknown;
+            update?: unknown;
+            delete?: unknown;
+            list?: unknown;
+            query?: unknown;
+            count?: unknown;
+        };
+    };
+}
+/**
+ * Creates a Convex-backed DbAdapter.
+ *
+ * Since Convex uses predefined queries/mutations rather than arbitrary SQL,
+ * you must provide function references for each collection. The adapter maps
+ * generic CRUD calls to these Convex functions.
+ *
+ * @example
+ * ```ts
+ * import { api } from '../convex/_generated/api'
+ *
+ * const db = createConvexDbAdapter({
+ *   client: convex,
+ *   functions: {
+ *     tasks: {
+ *       create: api.tasks.create,
+ *       get: api.tasks.get,
+ *       list: api.tasks.list,
+ *       update: api.tasks.update,
+ *       delete: api.tasks.remove,
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function createConvexDbAdapter(options: ConvexDbAdapterOptions): DbAdapter;
+
+interface DrizzleTable {
+    [key: string]: unknown;
+}
+interface DrizzleClient {
+    select: (fields?: Record<string, unknown>) => unknown;
+    insert: (table: unknown) => unknown;
+    update: (table: unknown) => unknown;
+    delete: (table: unknown) => unknown;
+}
+/** Drizzle operator functions — injected by the consumer */
+interface DrizzleOperators {
+    eq: (col: unknown, value: unknown) => unknown;
+    ne: (col: unknown, value: unknown) => unknown;
+    gt: (col: unknown, value: unknown) => unknown;
+    gte: (col: unknown, value: unknown) => unknown;
+    lt: (col: unknown, value: unknown) => unknown;
+    lte: (col: unknown, value: unknown) => unknown;
+    inArray: (col: unknown, values: unknown[]) => unknown;
+    like: (col: unknown, pattern: string) => unknown;
+    and: (...conditions: unknown[]) => unknown;
+    asc: (col: unknown) => unknown;
+    desc: (col: unknown) => unknown;
+    sql: unknown;
+    count: (col?: unknown) => unknown;
+}
+interface NeonDbAdapterOptions {
+    /** Pre-configured Drizzle client instance */
+    client: DrizzleClient;
+    /** Map of collection names to Drizzle table schema objects */
+    tables: Record<string, DrizzleTable>;
+    /** Drizzle operator functions (import from 'drizzle-orm') */
+    operators: DrizzleOperators;
+}
+/**
+ * Creates a Neon-backed DbAdapter using Drizzle ORM.
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/neon-http'
+ * import { neon } from '@neondatabase/serverless'
+ * import { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql, count } from 'drizzle-orm'
+ * import * as schema from './schema'
+ *
+ * const db = drizzle(neon(process.env.DATABASE_URL!))
+ *
+ * const adapter = createNeonDbAdapter({
+ *   client: db,
+ *   tables: { tasks: schema.tasks },
+ *   operators: { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql, count },
+ * })
+ * ```
+ */
+declare function createNeonDbAdapter(options: NeonDbAdapterOptions): DbAdapter;
+
+interface SupabaseClient {
+    from: (table: string) => SupabaseQueryBuilder;
+}
+interface SupabaseQueryBuilder {
+    select: (columns?: string) => SupabaseQueryBuilder;
+    insert: (data: Record<string, unknown>) => SupabaseQueryBuilder;
+    update: (data: Record<string, unknown>) => SupabaseQueryBuilder;
+    delete: () => SupabaseQueryBuilder;
+    eq: (column: string, value: unknown) => SupabaseQueryBuilder;
+    neq: (column: string, value: unknown) => SupabaseQueryBuilder;
+    gt: (column: string, value: unknown) => SupabaseQueryBuilder;
+    gte: (column: string, value: unknown) => SupabaseQueryBuilder;
+    lt: (column: string, value: unknown) => SupabaseQueryBuilder;
+    lte: (column: string, value: unknown) => SupabaseQueryBuilder;
+    in: (column: string, values: unknown[]) => SupabaseQueryBuilder;
+    ilike: (column: string, pattern: string) => SupabaseQueryBuilder;
+    order: (column: string, options?: {
+        ascending?: boolean;
+    }) => SupabaseQueryBuilder;
+    range: (from: number, to: number) => SupabaseQueryBuilder;
+    limit: (count: number) => SupabaseQueryBuilder;
+    single: () => SupabaseQueryBuilder;
+    then: (resolve: (value: {
+        data: unknown;
+        error: {
+            message: string;
+        } | null;
+    }) => void) => Promise<unknown>;
+}
+interface SupabaseDbAdapterOptions {
+    /** Pre-configured Supabase client instance */
+    client: SupabaseClient;
+    /** Optional table name mapping: { collectionName: 'actual_table_name' } */
+    tableNames?: Record<string, string>;
+}
+/**
+ * Creates a Supabase-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient(url, key)
+ * const db = createSupabaseDbAdapter({ client: supabase })
+ * ```
+ */
+declare function createSupabaseDbAdapter(options: SupabaseDbAdapterOptions): DbAdapter;
+
+interface MongoCollection {
+    insertOne: (doc: Record<string, unknown>) => Promise<{
+        insertedId: unknown;
+    }>;
+    findOne: (filter: Record<string, unknown>) => Promise<Record<string, unknown> | null>;
+    updateOne: (filter: Record<string, unknown>, update: Record<string, unknown>) => Promise<unknown>;
+    deleteOne: (filter: Record<string, unknown>) => Promise<{
+        deletedCount: number;
+    }>;
+    find: (filter?: Record<string, unknown>) => MongoCursor;
+    countDocuments: (filter?: Record<string, unknown>) => Promise<number>;
+}
+interface MongoCursor {
+    sort: (sort: Record<string, number>) => MongoCursor;
+    skip: (n: number) => MongoCursor;
+    limit: (n: number) => MongoCursor;
+    toArray: () => Promise<Record<string, unknown>[]>;
+}
+interface MongoDb {
+    collection: (name: string) => MongoCollection;
+}
+interface MongoDbAdapterOptions {
+    /** Pre-configured MongoDB database instance */
+    db: MongoDb;
+    /** Optional collection name mapping */
+    collectionNames?: Record<string, string>;
+}
+/**
+ * Creates a MongoDB-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { MongoClient } from 'mongodb'
+ *
+ * const client = new MongoClient(process.env.MONGODB_URI!)
+ * const db = client.db('myapp')
+ * const adapter = createMongoDbAdapter({ db })
+ * ```
+ */
+declare function createMongoDbAdapter(options: MongoDbAdapterOptions): DbAdapter;
+
+interface KVNamespaceLike {
+    get(key: string, type: 'json'): Promise<unknown>;
+    put(key: string, value: string): Promise<void>;
+}
+declare function createCloudflareKVDbAdapter(kv: KVNamespaceLike): DbAdapter;
+
+declare function createMemoryDbAdapter(): DbAdapter;
+
+declare function createLocalStoragePaymentsAdapter(): PaymentsAdapter;
+declare function createNoopPaymentsAdapter(): PaymentsAdapter;
+
+declare function createLocalStorageAiAdapter(): AiAdapter;
+
+declare function createLocalStorageFileAdapter(): FileStorageAdapter;
+
+declare function createLocalStorageAdminAdapter(): AdminAdapter;
+
+type ProjectTier = 'pronto' | 'lancio' | 'studio';
+/** Feature access rules per tier */
+interface TierGateConfig {
+    /** Features available in each tier (cumulative — higher tiers include lower) */
+    features: Record<ProjectTier, string[]>;
+    /** UI component packages available per tier */
+    packages: Record<ProjectTier, string[]>;
+}
+declare const DEFAULT_TIER_GATE: TierGateConfig;
+/** Check if a feature is available for a given tier */
+declare function isFeatureAvailable(feature: string, tier: ProjectTier): boolean;
+/** Check if a package is available for a given tier */
+declare function isPackageAvailable(pkg: string, tier: ProjectTier): boolean;
+/** Get all features available for a tier */
+declare function getAvailableFeatures(tier: ProjectTier): string[];
+/** Get all packages available for a tier */
+declare function getAvailablePackages(tier: ProjectTier): string[];
+/** Get the features that would be unlocked by upgrading to a higher tier */
+declare function getUpgradeFeatures(currentTier: ProjectTier, targetTier: ProjectTier): string[];
+
+export { ADAPTER_DOMAINS, ADAPTER_STATUSES, ADMIN_PROVIDERS, AI_PROVIDERS, AUTH_PROVIDERS, type AdapterConfig, type AdapterDomain, AdapterError, type AdapterRegistryEntry, type AdapterStatus, type AdapterStatusInfo, type AdapterStatusType, type AdminAdapter, AdminError, type AdminErrorCode, type AdminMetrics, type AdminProviderName, type AiAdapter, AiError, type AiErrorCode, type AiOptions, type AiProviderName, type AuthAdapter, AuthError, type AuthErrorCode, type AuthProviderName, type AuthSession, type AuthUser, type ChatMessage, type ChatResponse, type ChatRole, type CheckoutParams, type CheckoutResult, type ConvexDbAdapterOptions, DB_PROVIDERS, DEFAULT_TIER_GATE, DOMAIN_DESCRIPTIONS, DOMAIN_ICONS, DOMAIN_LABELS, type DbAdapter, DbError, type DbErrorCode, type DbProviderName, type DomainAdapterConfig, type FileStorageAdapter, type KVNamespaceLike, type ListOptions, type ManagedUser, type MongoDbAdapterOptions, type NeonDbAdapterOptions, type OAuthProvider, PAYMENT_PROVIDERS, PROVIDER_REGISTRY, type PaymentProviderName, type PaymentsAdapter, PaymentsError, type PaymentsErrorCode, type Plan, type ProjectTier, type ProviderMeta, type QueryCondition, type QueryFilter, type QueryOperator, type RetryOptions, STORAGE_PROVIDERS, StorageError, type StorageErrorCode, type StorageProviderName, type StoredFile, type Subscription, type SupabaseDbAdapterOptions, type TierGateConfig, clearResolvers, configureAdapters, createCloudflareKVDbAdapter, createConvexDbAdapter, createLocalStorageAdminAdapter, createLocalStorageAiAdapter, createLocalStorageAuthAdapter, createLocalStorageDbAdapter, createLocalStorageFileAdapter, createLocalStoragePaymentsAdapter, createMemoryDbAdapter, createMongoDbAdapter, createNeonDbAdapter, createNoopPaymentsAdapter, createSupabaseDbAdapter, getAdapterConfig, getAvailableFeatures, getAvailablePackages, getDomainConfig, getProviderMeta, getProvidersForDomain, getUpgradeFeatures, hasResolver, isAdapterError, isAdaptersConfigured, isFeatureAvailable, isPackageAvailable, isRetryable, registerResolver, resetAdapterConfig, resolveAdapter, withRetry };