@vaiftechnologies/vaif-client 0.1.2 → 0.2.1

package/dist/index.d.cts

@@ -1,3 +1,93 @@
+/**
+ * Retry configuration for automatic request retries
+ */
+interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial delay between retries in ms (default: 1000) */
+    retryDelay?: number;
+    /** Maximum delay between retries in ms (default: 30000) */
+    maxRetryDelay?: number;
+    /** Backoff multiplier (default: 2) */
+    backoffMultiplier?: number;
+    /** HTTP status codes to retry on (default: [429, 500, 502, 503, 504]) */
+    retryOn?: number[];
+    /** Retry on network errors (default: true) */
+    retryOnNetworkError?: boolean;
+}
+/**
+ * Fully resolved retry configuration with defaults applied
+ */
+interface ResolvedRetryConfig {
+    maxRetries: number;
+    retryDelay: number;
+    maxRetryDelay: number;
+    backoffMultiplier: number;
+    retryOn: number[];
+    retryOnNetworkError: boolean;
+}
+/**
+ * Context passed to request interceptors
+ */
+interface RequestContext {
+    /** Full URL being requested */
+    url: string;
+    /** API path (without base URL) */
+    path: string;
+    /** HTTP method */
+    method: string;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request body (if any) */
+    body?: string;
+    /** Current retry attempt (0-based) */
+    attempt: number;
+}
+/**
+ * Context passed to response interceptors
+ */
+interface ResponseContext<T = unknown> {
+    /** Original request context */
+    request: RequestContext;
+    /** Parsed response data */
+    data: T;
+    /** HTTP status code */
+    status: number;
+    /** Response headers */
+    headers: Record<string, string>;
+    /** Request duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Context passed to error interceptors
+ */
+interface ErrorContext {
+    /** Original request context */
+    request: RequestContext;
+    /** The error that occurred */
+    error: Error;
+    /** Request duration in milliseconds */
+    durationMs: number;
+    /** Whether the request will be retried */
+    willRetry: boolean;
+}
+/** Intercept and optionally modify outgoing requests */
+type RequestInterceptor = (context: RequestContext) => RequestContext | void | Promise<RequestContext | void>;
+/** Observe successful responses */
+type ResponseInterceptor = (context: ResponseContext) => void | Promise<void>;
+/** Observe request errors */
+type ErrorInterceptor = (context: ErrorContext) => void | Promise<void>;
+/**
+ * Interceptor configuration for request/response observation
+ */
+interface InterceptorConfig {
+    /** Called before each request. Can modify the request context. */
+    onRequest?: RequestInterceptor;
+    /** Called after each successful response. */
+    onResponse?: ResponseInterceptor;
+    /** Called on request errors. */
+    onError?: ErrorInterceptor;
+}
 /**
  * Configuration options for creating a VAIF client
  */
@@ -54,6 +144,14 @@ interface VaifClientOptions {
      * Custom storage implementation for session persistence
      */
     storage?: StorageAdapter;
+    /**
+     * Retry configuration for automatic request retries with exponential backoff
+     */
+    retry?: RetryConfig;
+    /**
+     * Request/response interceptors for observability and modification
+     */
+    interceptors?: InterceptorConfig;
 }
 /**
  * Internal configuration after processing options
@@ -70,6 +168,8 @@ interface VaifConfig {
     autoRefreshToken: boolean;
     persistSession: boolean;
     storage: StorageAdapter;
+    retry: ResolvedRetryConfig;
+    interceptors: InterceptorConfig;
 }
 /**
  * Storage adapter interface for session persistence
@@ -154,6 +254,56 @@ interface ApiError {
      */
     requestId?: string;
 }
+/**
+ * Pagination parameters
+ */
+interface PaginationParams {
+    /**
+     * Page number (1-indexed)
+     */
+    page?: number;
+    /**
+     * Items per page
+     */
+    limit?: number;
+    /**
+     * Offset for cursor-based pagination
+     */
+    offset?: number;
+    /**
+     * Cursor for cursor-based pagination
+     */
+    cursor?: string;
+}
+/**
+ * Paginated response
+ */
+interface PaginatedResponse<T> {
+    /**
+     * Array of items
+     */
+    data: T[];
+    /**
+     * Total count of items
+     */
+    total: number;
+    /**
+     * Current page number
+     */
+    page: number;
+    /**
+     * Items per page
+     */
+    limit: number;
+    /**
+     * Whether there are more items
+     */
+    hasMore: boolean;
+    /**
+     * Next page cursor (if using cursor pagination)
+     */
+    nextCursor?: string;
+}
 
 /**
  * Database query types for VAIF Studio
@@ -414,15 +564,60 @@ interface QueryError {
      */
     hint?: string;
 }
+/**
+ * Transaction options
+ */
+interface TransactionOptions {
+    /**
+     * Isolation level
+     */
+    isolationLevel?: 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
+}
+/**
+ * Transaction interface
+ */
+interface Transaction {
+    /**
+     * Execute query within transaction
+     */
+    from<T = Record<string, unknown>>(table: string): SelectQuery<T>;
+    /**
+     * Commit transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback transaction
+     */
+    rollback(): Promise<void>;
+}
 
 /**
  * VAIF Database Client
  *
- * Provides type-safe database operations with a fluent query builder
+ * Provides type-safe database operations with a fluent query builder.
+ * Supports SELECT, INSERT, UPDATE, DELETE, upsert, raw SQL, and stored procedures.
  */
 
 /**
  * Database client for VAIF Studio
+ *
+ * @example
+ * ```typescript
+ * // Query with fluent builder
+ * const result = await vaif.db.from('users')
+ *   .select('id, name, email')
+ *   .eq('active', true)
+ *   .order('created_at', { ascending: false })
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Insert with upsert
+ * const upserted = await vaif.db.from('users')
+ *   .insert({ email: 'user@example.com', name: 'User' })
+ *   .onConflict('email')
+ *   .doUpdate({ name: 'Updated User' })
+ *   .execute();
+ * ```
  */
 declare class VaifDatabase {
     private client;
@@ -430,6 +625,9 @@ declare class VaifDatabase {
     /**
      * Start a query on a table
      *
+     * @param table - Table name to query
+     * @returns A query builder for chaining operations
+     *
      * @example
      * ```typescript
      * const users = await vaif.db.from('users').select('*').execute();
@@ -439,6 +637,10 @@ declare class VaifDatabase {
     /**
      * Execute raw SQL query (admin only)
      *
+     * @param sql - SQL query string with $1, $2, etc. parameter placeholders
+     * @param params - Parameter values for the query
+     * @returns Query result with typed rows
+     *
      * @example
      * ```typescript
      * const result = await vaif.db.raw('SELECT * FROM users WHERE id = $1', [userId]);
@@ -446,7 +648,16 @@ declare class VaifDatabase {
      */
     raw<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T[]>>;
     /**
-     * Execute a function (stored procedure)
+     * Execute a stored procedure (RPC call)
+     *
+     * @param functionName - Name of the database function to call
+     * @param params - Parameters to pass to the function
+     * @returns Query result with the function's return value
+     *
+     * @example
+     * ```typescript
+     * const result = await vaif.db.rpc('get_user_stats', { userId: '123' });
+     * ```
      */
     rpc<T = unknown>(functionName: string, params?: Record<string, unknown>): Promise<QueryResult<T>>;
 }
@@ -499,19 +710,33 @@ declare class QueryBuilder<T = Record<string, unknown>> {
      * Update on conflict
      */
     doUpdate(data: Partial<T>): this;
+    /** Filter by equality (column = value) */
     eq(column: keyof T | string, value: unknown): this;
+    /** Filter by inequality (column != value) */
     neq(column: keyof T | string, value: unknown): this;
+    /** Filter by greater than (column > value) */
     gt(column: keyof T | string, value: unknown): this;
+    /** Filter by greater than or equal (column >= value) */
     gte(column: keyof T | string, value: unknown): this;
+    /** Filter by less than (column < value) */
     lt(column: keyof T | string, value: unknown): this;
+    /** Filter by less than or equal (column <= value) */
     lte(column: keyof T | string, value: unknown): this;
+    /** Filter by pattern matching (case-sensitive LIKE) */
     like(column: keyof T | string, pattern: string): this;
+    /** Filter by pattern matching (case-insensitive ILIKE) */
     ilike(column: keyof T | string, pattern: string): this;
+    /** Filter by IS (null/boolean checks) */
     is(column: keyof T | string, value: null | boolean): this;
+    /** Filter by inclusion in an array of values */
     in(column: keyof T | string, values: unknown[]): this;
+    /** Filter by array containment (@>) */
     contains(column: keyof T | string, value: unknown[]): this;
+    /** Filter by array being contained by (<@) */
     containedBy(column: keyof T | string, value: unknown[]): this;
+    /** Filter by array overlap (&&) */
     overlaps(column: keyof T | string, value: unknown[]): this;
+    /** Full-text search filter */
     textSearch(column: keyof T | string, query: string, options?: {
         config?: string;
     }): this;
@@ -1766,6 +1991,35 @@ interface OAuthResponse {
      */
     url: string;
 }
+/**
+ * MFA factor
+ */
+interface MFAFactor {
+    /**
+     * Factor ID
+     */
+    id: string;
+    /**
+     * Factor type
+     */
+    factorType: 'totp' | 'phone';
+    /**
+     * Friendly name
+     */
+    friendlyName?: string;
+    /**
+     * Factor status
+     */
+    status: 'unverified' | 'verified';
+    /**
+     * Created timestamp
+     */
+    createdAt: string;
+    /**
+     * Updated timestamp
+     */
+    updatedAt: string;
+}
 
 /**
  * VAIF Auth Client
@@ -2293,6 +2547,142 @@ interface AICreditsInfo {
      */
     resetDate: string;
 }
+/**
+ * Copilot metrics summary
+ */
+interface CopilotMetricsSummary {
+    /**
+     * Total generation requests
+     */
+    totalRequests: number;
+    /**
+     * Successful requests
+     */
+    successfulRequests: number;
+    /**
+     * Failed requests
+     */
+    failedRequests: number;
+    /**
+     * Success rate percentage
+     */
+    successRate: number;
+    /**
+     * Total tokens used
+     */
+    totalTokens: number;
+    /**
+     * Total credits consumed
+     */
+    totalCredits: number;
+    /**
+     * Total unique sessions
+     */
+    totalSessions: number;
+    /**
+     * Batch completion rate percentage
+     */
+    batchCompletionRate: number;
+    /**
+     * Average files generated per session
+     */
+    avgFilesPerSession: number;
+}
+/**
+ * Token trend data point
+ */
+interface CopilotTokenTrend {
+    /**
+     * Timestamp (ISO string)
+     */
+    timestamp: string;
+    /**
+     * Input tokens used
+     */
+    inputTokens: number;
+    /**
+     * Output tokens used
+     */
+    outputTokens: number;
+    /**
+     * Total tokens
+     */
+    totalTokens: number;
+    /**
+     * Number of requests
+     */
+    requests: number;
+}
+/**
+ * Copilot metrics response
+ */
+interface CopilotMetrics {
+    /**
+     * Project ID
+     */
+    projectId: string;
+    /**
+     * Organization ID
+     */
+    orgId: string;
+    /**
+     * Time range used
+     */
+    range: string;
+    /**
+     * Start date (ISO string)
+     */
+    startDate: string;
+    /**
+     * End date (ISO string)
+     */
+    endDate: string;
+    /**
+     * Summary metrics
+     */
+    summary: CopilotMetricsSummary;
+    /**
+     * Average latency by model tier (ms)
+     */
+    avgLatencyByTier: Record<string, number>;
+    /**
+     * Token usage by model tier
+     */
+    tokensByTier: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>;
+    /**
+     * Credits consumed by generation type
+     */
+    creditsByType: Record<string, number>;
+    /**
+     * Request counts by type
+     */
+    requestTypeCount: Record<string, number>;
+    /**
+     * Counts by generation type (schema, functions, etc.)
+     */
+    generationTypeCount: Record<string, number>;
+    /**
+     * Error code frequencies
+     */
+    errorCodes: Record<string, number>;
+    /**
+     * Hourly token usage trends
+     */
+    tokenTrends: CopilotTokenTrend[];
+}
+/**
+ * Copilot metrics request options
+ */
+interface CopilotMetricsOptions {
+    /**
+     * Time range
+     */
+    range?: '1h' | '6h' | '24h' | '7d' | '30d';
+}
 
 /**
  * VAIF AI Client
@@ -2502,6 +2892,34 @@ declare class VaifAI {
         } | null;
         error: AIError | null;
     }>;
+    /**
+     * Get Copilot observability metrics for the current project
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.getCopilotMetrics({ range: '24h' });
+     * console.log(`Success rate: ${data.summary.successRate}%`);
+     * console.log(`Total tokens: ${data.summary.totalTokens}`);
+     * ```
+     */
+    getCopilotMetrics(options?: CopilotMetricsOptions): Promise<{
+        data: CopilotMetrics | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Get Copilot observability metrics for an organization
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.getCopilotOrgMetrics(orgId, { range: '7d' });
+     * console.log(`Total requests: ${data.summary.totalRequests}`);
+     * console.log(`Projects: ${data.summary.uniqueProjects}`);
+     * ```
+     */
+    getCopilotOrgMetrics(orgId: string, options?: CopilotMetricsOptions): Promise<{
+        data: CopilotMetrics | null;
+        error: AIError | null;
+    }>;
 }
 
 /**
@@ -3574,10 +3992,118 @@ declare class VaifIntegrations {
     getFailedDeliveries(projectId: string, limit?: number): Promise<WebhookDelivery[]>;
 }
 
+/**
+ * VAIF SDK Error Classes
+ *
+ * Typed error hierarchy for consistent error handling across the SDK.
+ */
+/**
+ * Base error class for all VAIF SDK errors
+ */
+declare class VaifError extends Error {
+    /** Error code for programmatic handling */
+    readonly code: string;
+    /** HTTP status code if applicable */
+    readonly statusCode?: number;
+    /** Request ID for support */
+    readonly requestId?: string;
+    /** Additional error details */
+    readonly details?: unknown;
+    constructor(message: string, options: {
+        code: string;
+        statusCode?: number;
+        requestId?: string;
+        details?: unknown;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        statusCode: number | undefined;
+        requestId: string | undefined;
+        details: unknown;
+    };
+}
+/**
+ * Authentication/authorization error (401, 403)
+ */
+declare class VaifAuthError extends VaifError {
+    constructor(message: string, options?: {
+        code?: string;
+        statusCode?: number;
+        requestId?: string;
+    });
+}
+/**
+ * Validation error (400) with optional field-level errors
+ */
+declare class VaifValidationError extends VaifError {
+    /** Field-level validation errors */
+    readonly fieldErrors?: Record<string, string[]>;
+    constructor(message: string, options?: {
+        fieldErrors?: Record<string, string[]>;
+        details?: unknown;
+        requestId?: string;
+    });
+}
+/**
+ * Network/connection error
+ */
+declare class VaifNetworkError extends VaifError {
+    /** Original error cause */
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Rate limit error (429)
+ */
+declare class VaifRateLimitError extends VaifError {
+    /** Seconds to wait before retrying */
+    readonly retryAfter?: number;
+    constructor(message: string, retryAfter?: number);
+}
+/**
+ * Resource not found error (404)
+ */
+declare class VaifNotFoundError extends VaifError {
+    constructor(message: string, requestId?: string);
+}
+/**
+ * Conflict error (409)
+ */
+declare class VaifConflictError extends VaifError {
+    constructor(message: string, requestId?: string);
+}
+/**
+ * Request timeout error
+ */
+declare class VaifTimeoutError extends VaifNetworkError {
+    /** Timeout duration in milliseconds */
+    readonly timeoutMs?: number;
+    constructor(message: string, timeoutMs?: number);
+}
+/** Check if an error is a VaifError */
+declare function isVaifError(error: unknown): error is VaifError;
+/** Check if an error is a VaifAuthError */
+declare function isVaifAuthError(error: unknown): error is VaifAuthError;
+/** Check if an error is a VaifValidationError */
+declare function isVaifValidationError(error: unknown): error is VaifValidationError;
+/** Check if an error is a VaifNetworkError */
+declare function isVaifNetworkError(error: unknown): error is VaifNetworkError;
+/** Check if an error is a VaifRateLimitError */
+declare function isVaifRateLimitError(error: unknown): error is VaifRateLimitError;
+/** Check if an error is a VaifNotFoundError */
+declare function isVaifNotFoundError(error: unknown): error is VaifNotFoundError;
+/** Check if an error is a VaifConflictError */
+declare function isVaifConflictError(error: unknown): error is VaifConflictError;
+/** Check if an error is a VaifTimeoutError */
+declare function isVaifTimeoutError(error: unknown): error is VaifTimeoutError;
+
 /**
  * VAIF Studio Client
  *
- * Main entry point for the VAIF SDK
+ * Main entry point for the VAIF SDK. Provides authenticated API requests
+ * with automatic retry, interceptors, and typed error handling.
  */
 
 /**
@@ -3596,89 +4122,65 @@ declare function createClient(options: VaifClientOptions): VaifClient;
  * VAIF Studio Client
  *
  * Provides access to all VAIF services:
- * - Database (db)
- * - Realtime subscriptions (realtime)
- * - Storage (storage)
- * - Edge Functions (functions)
- * - Authentication (auth)
- * - AI Generation (ai)
+ * - Database (db) - CRUD operations with fluent query builder
+ * - Realtime (realtime) - WebSocket subscriptions for live data
+ * - Storage (storage) - File upload/download with CDN
+ * - Functions (functions) - Edge function invocation
+ * - Authentication (auth) - User auth with OAuth, OTP, etc.
+ * - AI (ai) - Code generation and AI chat
+ * - Schema (schema) - Database schema management
+ * - TypeGen (typegen) - TypeScript type generation from DB schema
+ * - Admin (admin) - Platform admin endpoints
+ * - Projects (projects) - Project management
+ * - API Keys (apiKeys) - API key management
+ * - Integrations (integrations) - Webhook and integration management
  */
 declare class VaifClient {
     private config;
     private accessToken;
-    /**
-     * Database client for CRUD operations
-     */
+    /** Database client for CRUD operations */
     readonly db: VaifDatabase;
-    /**
-     * Realtime client for subscriptions
-     */
+    /** Realtime client for WebSocket subscriptions */
     readonly realtime: VaifRealtime;
-    /**
-     * Storage client for file operations
-     */
+    /** Storage client for file operations */
     readonly storage: VaifStorage;
-    /**
-     * Functions client for edge function invocation
-     */
+    /** Functions client for edge function invocation */
     readonly functions: VaifFunctions;
-    /**
-     * Auth client for authentication
-     */
+    /** Auth client for authentication */
     readonly auth: VaifAuth;
-    /**
-     * AI client for generation features
-     */
+    /** AI client for generation features */
     readonly ai: VaifAI;
-    /**
-     * Schema Engine client for schema management and migrations
-     */
+    /** Schema Engine client for schema management and migrations */
     readonly schema: VaifSchema;
-    /**
-     * Type generator for generating TypeScript types from database schema
-     */
+    /** Type generator for generating TypeScript types from database schema */
     readonly typegen: VaifTypeGen;
-    /**
-     * Admin client for platform management (admin-only endpoints)
-     */
+    /** Admin client for platform management (admin-only endpoints) */
     readonly admin: VaifAdmin;
-    /**
-     * Projects client for project management
-     */
+    /** Projects client for project management */
     readonly projects: VaifProjects;
-    /**
-     * API Keys client for API key management
-     */
+    /** API Keys client for API key management */
     readonly apiKeys: VaifApiKeys;
-    /**
-     * Integrations client for managing webhooks and integrations
-     */
+    /** Integrations client for managing webhooks and integrations */
     readonly integrations: VaifIntegrations;
     constructor(options: VaifClientOptions);
-    /**
-     * Get current configuration
-     */
+    /** Get current configuration */
     getConfig(): VaifConfig;
-    /**
-     * Set access token for authenticated requests
-     */
+    /** Set access token for authenticated requests */
     setAccessToken(token: string | null): void;
-    /**
-     * Get current access token
-     */
+    /** Get current access token */
     getAccessToken(): string | null;
     /**
-     * Make an authenticated API request
+     * Make an authenticated API request with automatic retry and interceptors
+     *
+     * @param path - API path (relative to base URL)
+     * @param options - Request options (method, body, params, etc.)
+     * @returns Typed API response with data, error, status, and headers
      */
     request<T = unknown>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
-    /**
-     * Restore session from storage
-     */
+    /** Restore session from storage */
     private restoreSession;
-    /**
-     * Log debug messages
-     */
+    /** Log debug messages (sanitised to avoid leaking tokens) */
     debug(...args: unknown[]): void;
 }
 
-export { type AIGenerateOptions, type AIModel, type AISession, type AddonsConfig, type AdminAdmin, type AdminIncident, type AdminOrg, type AdminOverview, type AdminProject, type AdminUser, type ApiError, type ApiKey, type ApiResponse, type ApiSettingsConfig, type AuthOptions, type AuthResponse, type Bucket, type ColumnDefinition, type ColumnSchema, type ComputeSettings, type ContextSnapshot, type CopilotOverview, type CopilotSession, type CreateApiKeyOptions$1 as CreateApiKeyOptions, type CreateApiKeyResult, type CreateIntegrationOptions, type CreateProjectOptions, type DatabaseSchema, type DeleteQuery, type DlqMessage, type DownloadOptions, type EndpointGenerationResult, type EnumSchema, type Environment, type FeatureFlag, type FileObject, type FilterOperator, type ForeignKeySchema, type FunctionError, type FunctionExecution, type FunctionGenerationResult, type FunctionInvocation, type FunctionInvokeOptions, type FunctionLog, type FunctionMetadata, type FunctionResponse, type GeneratedBackend, type HealthComponent, type IndexDefinition, type IndexSchema, type InsertQuery, type Integration, type IntegrationConfig, type JwtSettingsConfig, type MigrationRecord, type MigrationsListResult, type OrderDirection, type PlanStep, type Project, type ProjectApiKey, type ProjectSettings, type PromptTemplate, type QueryBuilder$1 as QueryBuilder, type QueueInfo, RealtimeChannel, type RealtimeEvent, type RealtimeMessage, type RealtimeOptions, type Region, type RequestOptions, type SchemaApplyRequest, type SchemaApplyResult, type SchemaDefinition, type SchemaGenerationResult, type SchemaIntrospectResult, type SchemaPreviewRequest, type SchemaPreviewResult, type SelectQuery, type Session, type SignInCredentials, type SignUpCredentials, type StorageOptions, type SubscriptionCallback, type TableDefinition, type TableSchema, type TypeGenOptions, type UpdateIntegrationOptions, type UpdateProjectOptions, type UpdateQuery, type UploadOptions, type User, VaifAI, VaifAdmin, VaifApiKeys, VaifAuth, VaifClient, type VaifClientOptions, type VaifConfig, VaifDatabase, type VaifFunction, VaifFunctions, VaifIntegrations, VaifProjects, VaifRealtime, VaifSchema, VaifStorage, VaifTypeGen, type ViewSchema, type WebhookDelivery, createClient, createTypeGen, createClient as createVaifClient };
+export { type AIChatMessage, type AIChatRequest, type AIChatResponse, type AICreditsInfo, type AIGenerateOptions, type AIModel, type AISession, type AISuggestion, type AddonsConfig, type AdminAdmin, type AdminIncident, type AdminOrg, type AdminOverview, type AdminProject, type AdminUser, type ApiError, type ApiKey, type ApiResponse, type ApiSettingsConfig, type AuthChangeEvent, type AuthError, type AuthOptions, type AuthResponse, type AuthStateChangeCallback, type BroadcastMessage, type Bucket, type ChannelStatus, type ColumnDefinition, type ColumnSchema, type ComputeSettings, type ContextSnapshot, type CopilotMetrics, type CopilotMetricsOptions, type CopilotMetricsSummary, type CopilotModel, type CopilotOverview, type CopilotSession, type CopilotTokenTrend, type CreateApiKeyOptions$1 as CreateApiKeyOptions, type CreateApiKeyResult, type CreateIntegrationOptions, type CreateProjectOptions, type DatabaseSchema, type DeleteQuery, type DlqMessage, type DownloadOptions, type EndpointGenerationRequest, type EndpointGenerationResult, type EnumSchema, type Environment, type ErrorContext, type ErrorInterceptor, type FeatureFlag, type FileObject, type FilterOperator, type ForeignKeySchema, type FunctionError, type FunctionExecution, type FunctionGenerationRequest, type FunctionGenerationResult, type FunctionInvocation, type FunctionInvokeOptions, type FunctionLog, type FunctionMetadata, type FunctionResponse, type GeneratedBackend, type HealthComponent, type ImageTransformOptions, type IndexDefinition, type IndexSchema, type InsertQuery, type Integration, type IntegrationConfig, type InterceptorConfig, type JwtSettingsConfig, type ListFilesOptions, type MFAFactor, type MigrationRecord, type MigrationsListResult, type OAuthProvider, type OAuthResponse, type OAuthSignInOptions, type OrderDirection, type PaginatedResponse, type PaginationParams, type PlanStep, type PostgresChangeEvent, type PostgresChangesFilter, type PresenceState, type PresenceSyncEvent, type Project, type ProjectApiKey, type ProjectSettings, type PromptTemplate, type QueryBuilder$1 as QueryBuilder, type QueryError, type QueryResult, type QueueInfo, RealtimeChannel, type RealtimeEvent, type RealtimeMessage, type RealtimeOptions, type Region, type RequestContext, type RequestInterceptor, type RequestOptions, type ResetPasswordOptions, type ResolvedRetryConfig, type ResponseContext, type ResponseInterceptor, type RetryConfig, type SchemaApplyRequest, type SchemaApplyResult, type SchemaDefinition, type SchemaGenerationRequest, type SchemaGenerationResult, type SchemaIntrospectResult, type SchemaPreviewRequest, type SchemaPreviewResult, type SelectQuery, type Session, type SignInCredentials, type SignUpCredentials, type SignedUrlOptions, type StorageAdapter, type StorageError, type StorageOptions, type SubscriptionCallback, type TableDefinition, type TableSchema, type Transaction, type TransactionOptions, type TypeGenOptions, type UpdateIntegrationOptions, type UpdateProjectOptions, type UpdateQuery, type UpdateUserOptions, type UploadOptions, type UploadResult, type User, VaifAI, VaifAdmin, VaifApiKeys, VaifAuth, VaifAuthError, VaifClient, type VaifClientOptions, type VaifConfig, VaifConflictError, VaifDatabase, VaifError, type VaifFunction, VaifFunctions, VaifIntegrations, VaifNetworkError, VaifNotFoundError, VaifProjects, VaifRateLimitError, VaifRealtime, VaifSchema, VaifStorage, VaifTimeoutError, VaifTypeGen, VaifValidationError, type ViewSchema, type WebhookDelivery, createClient, createTypeGen, createClient as createVaifClient, isVaifAuthError, isVaifConflictError, isVaifError, isVaifNetworkError, isVaifNotFoundError, isVaifRateLimitError, isVaifTimeoutError, isVaifValidationError };