@tspvivek/baasix-sdk 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1498 @@
+import { H as HttpClient, e as PaginatedResponse, N as Notification, o as SendNotificationData, p as Permission, C as CreatePermissionData, q as Role$1, r as Settings, s as ReportConfig, t as ReportResult, u as Aggregate, F as Filter, W as Workflow, v as WorkflowExecution, B as BaseItem, w as BaasixConfig, A as AuthMode } from './client-CzF9B60b.js';
+export { V as AggregateConfig, O as AggregateFunction, k as AssetTransformOptions, b as AuthResponse, d as AuthState, a as AuthStateEvent, c as AuthTokens, a3 as BaasixError, a2 as BaasixErrorDetails, f as BulkResponse, a5 as CollectionItem, a4 as DeepPartial, D as DeleteResponse, Y as FieldDefinition, X as FieldType, j as FileMetadata, G as FilterCondition, z as FilterOperator, E as FilterValue, y as HttpClientConfig, I as IndexDefinition, J as LogicalFilter, L as LoginCredentials, M as MagicLinkOptions, g as MutationResponse, P as PasswordResetOptions, _ as PermissionAction, Q as QueryParams, R as RegisterData, n as RelationshipDefinition, Z as RelationshipType, x as RequestOptions, m as SchemaDefinition, l as SchemaInfo, h as SingleResponse, S as Sort, K as SortDirection, T as Tenant, i as UploadOptions, U as User, a1 as WorkflowEdge, a0 as WorkflowNode, $ as WorkflowTrigger } from './client-CzF9B60b.js';
+import { S as StorageAdapter } from './types-BdjsGANq.js';
+export { a as STORAGE_KEYS, b as StorageKey } from './types-BdjsGANq.js';
+import { AuthModule } from './modules/auth.js';
+export { InviteOptions, OAuthOptions, OAuthProvider, VerifyInviteResult } from './modules/auth.js';
+import { ItemsModule } from './modules/items.js';
+export { ImportResult, QueryBuilder } from './modules/items.js';
+import { FilesModule } from './modules/files.js';
+import { SchemasModule } from './modules/schemas.js';
+export { AsyncStorageAdapter, LocalStorageAdapter, MemoryStorageAdapter } from './storage/index.js';
+
+interface NotificationsModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Notifications module for managing user notifications.
+ *
+ * @example
+ * ```typescript
+ * // Get user notifications
+ * const { data } = await baasix.notifications.find();
+ *
+ * // Mark as seen
+ * await baasix.notifications.markAsSeen('notification-id');
+ *
+ * // Send notification (admin)
+ * await baasix.notifications.send({
+ *   title: 'New Message',
+ *   message: 'You have a new message',
+ *   userIds: ['user-uuid']
+ * });
+ * ```
+ */
+declare class NotificationsModule {
+    private client;
+    constructor(config: NotificationsModuleConfig);
+    /**
+     * List notifications for the current user
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.notifications.find({
+     *   limit: 20,
+     *   filter: { seen: { eq: false } }
+     * });
+     * ```
+     */
+    find(params?: {
+        limit?: number;
+        page?: number;
+        seen?: boolean;
+    }): Promise<PaginatedResponse<Notification>>;
+    /**
+     * Get a single notification by ID
+     */
+    findOne(id: string): Promise<Notification>;
+    /**
+     * Mark a notification as seen
+     *
+     * @example
+     * ```typescript
+     * await baasix.notifications.markAsSeen('notification-uuid');
+     * ```
+     */
+    markAsSeen(id: string): Promise<void>;
+    /**
+     * Mark multiple notifications as seen
+     *
+     * @example
+     * ```typescript
+     * await baasix.notifications.markManySeen(['id1', 'id2', 'id3']);
+     * ```
+     */
+    markManySeen(ids: string[]): Promise<void>;
+    /**
+     * Mark all notifications as seen
+     *
+     * @example
+     * ```typescript
+     * await baasix.notifications.markAllSeen();
+     * ```
+     */
+    markAllSeen(): Promise<void>;
+    /**
+     * Get unread notification count
+     *
+     * @example
+     * ```typescript
+     * const count = await baasix.notifications.getUnreadCount();
+     * ```
+     */
+    getUnreadCount(): Promise<number>;
+    /**
+     * Delete a notification
+     *
+     * @example
+     * ```typescript
+     * await baasix.notifications.delete('notification-uuid');
+     * ```
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Send a notification to users (requires admin permissions)
+     *
+     * @example
+     * ```typescript
+     * await baasix.notifications.send({
+     *   type: 'alert',
+     *   title: 'System Update',
+     *   message: 'The system will be down for maintenance',
+     *   data: { link: '/updates' },
+     *   userIds: ['user1-uuid', 'user2-uuid']
+     * });
+     * ```
+     */
+    send(data: SendNotificationData): Promise<void>;
+}
+
+interface PermissionsModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Permissions module for managing role-based access control.
+ *
+ * @example
+ * ```typescript
+ * // Create a permission
+ * await baasix.permissions.create({
+ *   role_Id: 'role-uuid',
+ *   collection: 'products',
+ *   action: 'read',
+ *   fields: ['*'],
+ *   conditions: { published: { eq: true } }
+ * });
+ *
+ * // Get permissions for a role
+ * const { data } = await baasix.permissions.findByRole('role-uuid');
+ * ```
+ */
+declare class PermissionsModule {
+    private client;
+    constructor(config: PermissionsModuleConfig);
+    /**
+     * List all permissions
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.permissions.find();
+     * ```
+     */
+    find(params?: {
+        limit?: number;
+        page?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<PaginatedResponse<Permission>>;
+    /**
+     * Get a permission by ID
+     */
+    findOne(id: string): Promise<Permission>;
+    /**
+     * Get permissions for a specific role
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.permissions.findByRole('role-uuid');
+     * ```
+     */
+    findByRole(roleId: string): Promise<PaginatedResponse<Permission>>;
+    /**
+     * Get permissions for a specific collection
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.permissions.findByCollection('products');
+     * ```
+     */
+    findByCollection(collection: string): Promise<PaginatedResponse<Permission>>;
+    /**
+     * Create a new permission
+     *
+     * @example
+     * ```typescript
+     * await baasix.permissions.create({
+     *   role_Id: 'editor-role-uuid',
+     *   collection: 'posts',
+     *   action: 'update',
+     *   fields: ['title', 'content', 'status'],
+     *   conditions: {
+     *     author_Id: { eq: '$CURRENT_USER' }
+     *   }
+     * });
+     * ```
+     */
+    create(data: CreatePermissionData): Promise<Permission>;
+    /**
+     * Update a permission
+     *
+     * @example
+     * ```typescript
+     * await baasix.permissions.update('permission-uuid', {
+     *   fields: ['*'],
+     *   conditions: null
+     * });
+     * ```
+     */
+    update(id: string, data: Partial<CreatePermissionData>): Promise<Permission>;
+    /**
+     * Delete a permission
+     *
+     * @example
+     * ```typescript
+     * await baasix.permissions.delete('permission-uuid');
+     * ```
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List all roles
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.permissions.getRoles();
+     * ```
+     */
+    getRoles(): Promise<PaginatedResponse<Role$1>>;
+    /**
+     * Create CRUD permissions for a collection
+     *
+     * @example
+     * ```typescript
+     * await baasix.permissions.createCrudPermissions('role-uuid', 'products', {
+     *   create: { fields: ['name', 'price', 'description'] },
+     *   read: { fields: ['*'] },
+     *   update: { fields: ['name', 'price', 'description'] },
+     *   delete: false
+     * });
+     * ```
+     */
+    createCrudPermissions(roleId: string, collection: string, config: {
+        create?: {
+            fields?: string[];
+            conditions?: Permission["conditions"];
+        } | false;
+        read?: {
+            fields?: string[];
+            conditions?: Permission["conditions"];
+        } | false;
+        update?: {
+            fields?: string[];
+            conditions?: Permission["conditions"];
+        } | false;
+        delete?: {
+            conditions?: Permission["conditions"];
+        } | false;
+    }): Promise<Permission[]>;
+    /**
+     * Reload permissions cache (admin only)
+     *
+     * @example
+     * ```typescript
+     * await baasix.permissions.reloadCache();
+     * ```
+     */
+    reloadCache(): Promise<void>;
+}
+
+interface SettingsModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Settings module for managing application settings.
+ *
+ * @example
+ * ```typescript
+ * // Get all settings
+ * const settings = await baasix.settings.get();
+ *
+ * // Update settings
+ * await baasix.settings.update({
+ *   appName: 'My App',
+ *   theme: 'dark'
+ * });
+ * ```
+ */
+declare class SettingsModule {
+    private client;
+    constructor(config: SettingsModuleConfig);
+    /**
+     * Get all settings
+     *
+     * @example
+     * ```typescript
+     * const settings = await baasix.settings.get();
+     * console.log(settings.appName);
+     * ```
+     */
+    get(): Promise<Settings>;
+    /**
+     * Get a specific setting by key
+     *
+     * @example
+     * ```typescript
+     * const appName = await baasix.settings.getKey('appName');
+     * ```
+     */
+    getKey<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Update settings
+     *
+     * @example
+     * ```typescript
+     * await baasix.settings.update({
+     *   appName: 'Updated App Name',
+     *   logo: 'file-uuid',
+     *   customConfig: {
+     *     feature1: true,
+     *     feature2: false
+     *   }
+     * });
+     * ```
+     */
+    update(settings: Partial<Settings>): Promise<Settings>;
+    /**
+     * Set a specific setting
+     *
+     * @example
+     * ```typescript
+     * await baasix.settings.set('appName', 'My New App Name');
+     * ```
+     */
+    set<T>(key: string, value: T): Promise<Settings>;
+}
+
+interface ReportsModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Reports module for generating analytics and reports.
+ *
+ * @example
+ * ```typescript
+ * // Generate sales report grouped by category
+ * const report = await baasix.reports.generate('orders', {
+ *   aggregate: {
+ *     totalSales: { function: 'sum', field: 'total' },
+ *     orderCount: { function: 'count', field: 'id' },
+ *     avgOrderValue: { function: 'avg', field: 'total' }
+ *   },
+ *   groupBy: 'category',
+ *   filter: { status: { eq: 'completed' } },
+ *   dateRange: {
+ *     start: '2025-01-01',
+ *     end: '2025-12-31',
+ *     field: 'createdAt'
+ *   }
+ * });
+ * ```
+ */
+declare class ReportsModule {
+    private client;
+    constructor(config: ReportsModuleConfig);
+    /**
+     * Generate a report for a collection
+     *
+     * @example
+     * ```typescript
+     * // Sales by month
+     * const report = await baasix.reports.generate('orders', {
+     *   aggregate: {
+     *     revenue: { function: 'sum', field: 'total' },
+     *     orders: { function: 'count', field: 'id' }
+     *   },
+     *   groupBy: 'month',
+     *   dateRange: {
+     *     start: '2025-01-01',
+     *     end: '2025-12-31'
+     *   }
+     * });
+     * ```
+     */
+    generate(collection: string, config: Omit<ReportConfig, "collection">): Promise<ReportResult>;
+    /**
+     * Get collection statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await baasix.reports.getStats('products');
+     * console.log(stats.totalCount, stats.recentCount);
+     * ```
+     */
+    getStats(collection: string, options?: {
+        timeframe?: "24h" | "7d" | "30d" | "90d" | "1y";
+    }): Promise<{
+        totalCount: number;
+        recentCount: number;
+        deletedCount?: number;
+        byDate?: Record<string, number>;
+    }>;
+    /**
+     * Generate an aggregation query
+     *
+     * @example
+     * ```typescript
+     * const results = await baasix.reports.aggregate('orders', {
+     *   aggregate: {
+     *     total: { function: 'sum', field: 'amount' },
+     *     count: { function: 'count', field: 'id' },
+     *     min: { function: 'min', field: 'amount' },
+     *     max: { function: 'max', field: 'amount' },
+     *     avg: { function: 'avg', field: 'amount' }
+     *   },
+     *   groupBy: ['status', 'paymentMethod'],
+     *   filter: { createdAt: { gte: '$NOW-DAYS_30' } }
+     * });
+     * ```
+     */
+    aggregate(collection: string, options: {
+        aggregate: Aggregate;
+        groupBy?: string[];
+        filter?: Filter;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Count items matching a filter
+     *
+     * @example
+     * ```typescript
+     * const activeUsers = await baasix.reports.count('users', {
+     *   status: { eq: 'active' }
+     * });
+     * ```
+     */
+    count(collection: string, filter?: Filter): Promise<number>;
+    /**
+     * Get distinct values for a field
+     *
+     * @example
+     * ```typescript
+     * const categories = await baasix.reports.distinct('products', 'category');
+     * ```
+     */
+    distinct(collection: string, field: string, filter?: Filter): Promise<unknown[]>;
+}
+
+interface WorkflowsModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Workflows module for managing visual workflow automation.
+ *
+ * @example
+ * ```typescript
+ * // Execute a workflow
+ * const result = await baasix.workflows.execute('workflow-uuid', {
+ *   orderId: 'order-123'
+ * });
+ *
+ * // Get workflow executions
+ * const { data } = await baasix.workflows.getExecutions('workflow-uuid');
+ * ```
+ */
+declare class WorkflowsModule {
+    private client;
+    constructor(config: WorkflowsModuleConfig);
+    /**
+     * List all workflows
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.workflows.find();
+     * ```
+     */
+    find(params?: {
+        limit?: number;
+        page?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<PaginatedResponse<Workflow>>;
+    /**
+     * Get a workflow by ID
+     *
+     * @example
+     * ```typescript
+     * const workflow = await baasix.workflows.findOne('workflow-uuid');
+     * ```
+     */
+    findOne(id: string): Promise<Workflow>;
+    /**
+     * Create a new workflow
+     *
+     * @example
+     * ```typescript
+     * const workflow = await baasix.workflows.create({
+     *   name: 'Order Processing',
+     *   description: 'Process new orders',
+     *   trigger: {
+     *     type: 'hook',
+     *     config: {
+     *       collection: 'orders',
+     *       event: 'items.create.after'
+     *     }
+     *   },
+     *   nodes: [...],
+     *   edges: [...],
+     *   isActive: true
+     * });
+     * ```
+     */
+    create(data: Omit<Workflow, "id" | "createdAt" | "updatedAt">): Promise<Workflow>;
+    /**
+     * Update a workflow
+     *
+     * @example
+     * ```typescript
+     * await baasix.workflows.update('workflow-uuid', {
+     *   name: 'Updated Workflow Name',
+     *   isActive: false
+     * });
+     * ```
+     */
+    update(id: string, data: Partial<Omit<Workflow, "id" | "createdAt" | "updatedAt">>): Promise<Workflow>;
+    /**
+     * Delete a workflow
+     *
+     * @example
+     * ```typescript
+     * await baasix.workflows.delete('workflow-uuid');
+     * ```
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Execute a workflow manually
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.workflows.execute('workflow-uuid', {
+     *   // Trigger data
+     *   customerId: 'customer-123',
+     *   action: 'sendEmail'
+     * });
+     * ```
+     */
+    execute(id: string, triggerData?: Record<string, unknown>): Promise<WorkflowExecution>;
+    /**
+     * Test a workflow without persisting execution
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.workflows.test('workflow-uuid', {
+     *   testData: { value: 123 }
+     * });
+     * ```
+     */
+    test(id: string, triggerData?: Record<string, unknown>): Promise<WorkflowExecution>;
+    /**
+     * Get workflow execution history
+     *
+     * @example
+     * ```typescript
+     * const { data } = await baasix.workflows.getExecutions('workflow-uuid', {
+     *   limit: 50
+     * });
+     * ```
+     */
+    getExecutions(id: string, params?: {
+        limit?: number;
+        page?: number;
+        status?: "pending" | "running" | "completed" | "failed";
+    }): Promise<PaginatedResponse<WorkflowExecution>>;
+    /**
+     * Get a specific execution
+     *
+     * @example
+     * ```typescript
+     * const execution = await baasix.workflows.getExecution(
+     *   'workflow-uuid',
+     *   'execution-uuid'
+     * );
+     * ```
+     */
+    getExecution(workflowId: string, executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Cancel a running execution
+     *
+     * @example
+     * ```typescript
+     * await baasix.workflows.cancelExecution('workflow-uuid', 'execution-uuid');
+     * ```
+     */
+    cancelExecution(workflowId: string, executionId: string): Promise<void>;
+    /**
+     * Enable a workflow
+     *
+     * @example
+     * ```typescript
+     * await baasix.workflows.enable('workflow-uuid');
+     * ```
+     */
+    enable(id: string): Promise<Workflow>;
+    /**
+     * Disable a workflow
+     *
+     * @example
+     * ```typescript
+     * await baasix.workflows.disable('workflow-uuid');
+     * ```
+     */
+    disable(id: string): Promise<Workflow>;
+    /**
+     * Duplicate a workflow
+     *
+     * @example
+     * ```typescript
+     * const newWorkflow = await baasix.workflows.duplicate('workflow-uuid', {
+     *   name: 'Copy of My Workflow'
+     * });
+     * ```
+     */
+    duplicate(id: string, overrides?: Partial<Omit<Workflow, "id" | "createdAt" | "updatedAt">>): Promise<Workflow>;
+}
+
+interface SocketOptions {
+    auth?: {
+        token?: string;
+    };
+    query?: Record<string, string>;
+    path?: string;
+    transports?: string[];
+    reconnection?: boolean;
+    reconnectionAttempts?: number;
+    reconnectionDelay?: number;
+    timeout?: number;
+}
+interface Socket {
+    connected: boolean;
+    id?: string;
+    on(event: string, callback: (...args: any[]) => void): void;
+    off(event: string, callback?: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+    connect(): void;
+    disconnect(): void;
+}
+type SocketIOClient = (url: string, options?: SocketOptions) => Socket;
+interface RealtimeConfig {
+    client: HttpClient;
+    storage: StorageAdapter;
+    socketUrl?: string;
+    socketPath?: string;
+}
+type SubscriptionEvent = "create" | "update" | "delete";
+interface SubscriptionPayload<T = any> {
+    action: SubscriptionEvent;
+    collection: string;
+    data: T;
+    timestamp: string;
+}
+interface WorkflowExecutionUpdate {
+    executionId: string | number;
+    status?: string;
+    nodeId?: string;
+    nodeName?: string;
+    message?: string;
+    progress?: number;
+    result?: any;
+    error?: string;
+    timestamp: string;
+}
+interface SubscriptionCallback<T = any> {
+    (payload: SubscriptionPayload<T>): void;
+}
+/**
+ * Realtime module for WebSocket-based real-time subscriptions.
+ *
+ * Requires socket.io-client to be installed separately:
+ * ```bash
+ * npm install socket.io-client
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { io } from 'socket.io-client';
+ *
+ * // Initialize realtime with socket.io client
+ * baasix.realtime.setSocketClient(io);
+ *
+ * // Connect to realtime server
+ * await baasix.realtime.connect();
+ *
+ * // Subscribe to collection changes
+ * const unsubscribe = baasix.realtime.subscribe('products', (payload) => {
+ *   console.log(`Product ${payload.action}:`, payload.data);
+ * });
+ *
+ * // Disconnect when done
+ * baasix.realtime.disconnect();
+ * ```
+ */
+declare class RealtimeModule {
+    private client;
+    private storage;
+    private socket;
+    private socketClient;
+    private socketUrl;
+    private socketPath;
+    private subscriptions;
+    private workflowCallbacks;
+    private connectionCallbacks;
+    private reconnecting;
+    private connectionPromise;
+    constructor(config: RealtimeConfig);
+    /**
+     * Set the socket.io client instance
+     * This allows the SDK to work without bundling socket.io-client
+     *
+     * @example
+     * ```typescript
+     * import { io } from 'socket.io-client';
+     * baasix.realtime.setSocketClient(io);
+     * ```
+     */
+    setSocketClient(socketIO: SocketIOClient): void;
+    /**
+     * Set the WebSocket server URL
+     * By default, uses the same URL as the API
+     */
+    setSocketUrl(url: string): void;
+    /**
+     * Check if socket.io client is available
+     */
+    private ensureSocketClient;
+    /**
+     * Get the authentication token for socket connection
+     */
+    private getAuthToken;
+    /**
+     * Connect to the realtime server
+     *
+     * @example
+     * ```typescript
+     * await baasix.realtime.connect();
+     * console.log('Connected to realtime server');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the realtime server
+     *
+     * @example
+     * ```typescript
+     * baasix.realtime.disconnect();
+     * ```
+     */
+    disconnect(): void;
+    /**
+     * Check if connected to the realtime server
+     */
+    get isConnected(): boolean;
+    /**
+     * Subscribe to connection state changes
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.onConnectionChange((connected) => {
+     *   console.log('Connection state:', connected ? 'online' : 'offline');
+     * });
+     * ```
+     */
+    onConnectionChange(callback: (connected: boolean) => void): () => void;
+    private notifyConnectionChange;
+    /**
+     * Subscribe to a collection for real-time updates
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to all changes
+     * const unsubscribe = baasix.realtime.subscribe('products', (payload) => {
+     *   console.log(`${payload.action}:`, payload.data);
+     * });
+     *
+     * // Subscribe to specific events
+     * const unsubscribe = baasix.realtime.subscribe('orders', (payload) => {
+     *   if (payload.action === 'create') {
+     *     console.log('New order:', payload.data);
+     *   }
+     * });
+     *
+     * // Unsubscribe when done
+     * unsubscribe();
+     * ```
+     */
+    subscribe<T extends BaseItem = BaseItem>(collection: string, callback: SubscriptionCallback<T>): () => void;
+    /**
+     * Subscribe to specific events on a collection
+     *
+     * @example
+     * ```typescript
+     * // Only listen for creates
+     * const unsubscribe = baasix.realtime.on('products', 'create', (data) => {
+     *   console.log('New product:', data);
+     * });
+     * ```
+     */
+    on<T extends BaseItem = BaseItem>(collection: string, event: SubscriptionEvent, callback: (data: T) => void): () => void;
+    /**
+     * Listen to all changes across all subscribed collections
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.onAny((collection, payload) => {
+     *   console.log(`${collection}:${payload.action}`, payload.data);
+     * });
+     * ```
+     */
+    onAny(callback: (collection: string, payload: SubscriptionPayload) => void): () => void;
+    private subscribeOnServer;
+    private unsubscribeOnServer;
+    private setupCollectionListeners;
+    private removeCollectionListeners;
+    private handleCollectionEvent;
+    private resubscribeAll;
+    /**
+     * Join a workflow execution room to receive real-time updates
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.subscribeToExecution(executionId, (update) => {
+     *   console.log('Execution update:', update);
+     *   if (update.status === 'complete') {
+     *     console.log('Workflow finished!');
+     *   }
+     * });
+     * ```
+     */
+    subscribeToExecution(executionId: string | number, callback: (data: WorkflowExecutionUpdate) => void): () => void;
+    private handleWorkflowUpdate;
+    /**
+     * Create a channel for a collection (Supabase-style API)
+     *
+     * @example
+     * ```typescript
+     * const channel = baasix.realtime
+     *   .channel('products')
+     *   .on('INSERT', (payload) => console.log('New:', payload))
+     *   .on('UPDATE', (payload) => console.log('Updated:', payload))
+     *   .on('DELETE', (payload) => console.log('Deleted:', payload))
+     *   .subscribe();
+     *
+     * // Later
+     * channel.unsubscribe();
+     * ```
+     */
+    channel(collection: string): RealtimeChannel;
+}
+/**
+ * Chainable channel for Supabase-style subscription API
+ */
+declare class RealtimeChannel {
+    private realtime;
+    private collection;
+    private handlers;
+    private unsubscribeFn;
+    constructor(realtime: RealtimeModule, collection: string);
+    /**
+     * Add an event handler (chainable)
+     *
+     * @param event - 'INSERT', 'UPDATE', 'DELETE', or '*' for all
+     * @param callback - Handler function
+     */
+    on(event: "INSERT" | "UPDATE" | "DELETE" | "*", callback: (payload: any) => void): this;
+    private mapEvent;
+    private addHandler;
+    /**
+     * Start the subscription
+     */
+    subscribe(): this;
+    /**
+     * Stop the subscription
+     */
+    unsubscribe(): void;
+}
+
+interface RolesModuleConfig {
+    client: HttpClient;
+}
+interface Role extends BaseItem {
+    name: string;
+    description?: string;
+    icon?: string;
+    ipWhitelist?: string;
+    enforceTotp?: boolean;
+    adminAccess?: boolean;
+    appAccess?: boolean;
+}
+interface CreateRoleData {
+    name: string;
+    description?: string;
+    icon?: string;
+    ipWhitelist?: string;
+    enforceTotp?: boolean;
+    adminAccess?: boolean;
+    appAccess?: boolean;
+}
+/**
+ * Roles module for managing user roles.
+ *
+ * @example
+ * ```typescript
+ * // List all roles
+ * const roles = await baasix.roles.find();
+ *
+ * // Create a new role
+ * const role = await baasix.roles.create({
+ *   name: 'Editor',
+ *   description: 'Can edit content'
+ * });
+ * ```
+ */
+declare class RolesModule {
+    private client;
+    private collection;
+    constructor(config: RolesModuleConfig);
+    /**
+     * Get all roles
+     *
+     * @example
+     * ```typescript
+     * const { data: roles } = await baasix.roles.find();
+     * ```
+     */
+    find(): Promise<{
+        data: Role[];
+        totalCount: number;
+    }>;
+    /**
+     * Get a role by ID
+     *
+     * @example
+     * ```typescript
+     * const role = await baasix.roles.findOne('role-uuid');
+     * ```
+     */
+    findOne(id: string): Promise<Role>;
+    /**
+     * Get a role by name
+     *
+     * @example
+     * ```typescript
+     * const role = await baasix.roles.findByName('Administrator');
+     * ```
+     */
+    findByName(name: string): Promise<Role | null>;
+    /**
+     * Create a new role
+     *
+     * @example
+     * ```typescript
+     * const id = await baasix.roles.create({
+     *   name: 'Editor',
+     *   description: 'Content editor role',
+     *   appAccess: true
+     * });
+     * ```
+     */
+    create(data: CreateRoleData): Promise<string>;
+    /**
+     * Update a role
+     *
+     * @example
+     * ```typescript
+     * await baasix.roles.update('role-uuid', {
+     *   description: 'Updated description'
+     * });
+     * ```
+     */
+    update(id: string, data: Partial<CreateRoleData>): Promise<void>;
+    /**
+     * Delete a role
+     *
+     * @example
+     * ```typescript
+     * await baasix.roles.delete('role-uuid');
+     * ```
+     */
+    delete(id: string): Promise<void>;
+}
+
+interface UsersModuleConfig {
+    client: HttpClient;
+}
+interface User {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    status?: "active" | "suspended" | "invited";
+    role_Id?: string;
+    role?: {
+        id: string;
+        name: string;
+    };
+    emailVerified?: boolean;
+    totpEnabled?: boolean;
+    lastAccess?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface CreateUserData {
+    email: string;
+    password?: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    status?: "active" | "suspended" | "invited";
+    role_Id?: string;
+}
+interface UpdateUserData {
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    status?: "active" | "suspended" | "invited";
+    role_Id?: string;
+}
+interface UserQueryOptions {
+    filter?: Record<string, any>;
+    sort?: string;
+    limit?: number;
+    page?: number;
+    fields?: string[];
+}
+/**
+ * Users module for managing users (admin operations).
+ *
+ * @example
+ * ```typescript
+ * // List all users
+ * const users = await baasix.users.find();
+ *
+ * // Create a new user
+ * const user = await baasix.users.create({
+ *   email: 'user@example.com',
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   role_Id: 'role-uuid'
+ * });
+ * ```
+ */
+declare class UsersModule {
+    private client;
+    private collection;
+    constructor(config: UsersModuleConfig);
+    /**
+     * Get all users with optional filtering
+     *
+     * @example
+     * ```typescript
+     * const { data: users } = await baasix.users.find({
+     *   filter: { status: { eq: 'active' } },
+     *   limit: 20
+     * });
+     * ```
+     */
+    find(options?: UserQueryOptions): Promise<{
+        data: User[];
+        totalCount: number;
+    }>;
+    /**
+     * Get a user by ID
+     *
+     * @example
+     * ```typescript
+     * const user = await baasix.users.findOne('user-uuid');
+     * ```
+     */
+    findOne(id: string, fields?: string[]): Promise<User>;
+    /**
+     * Get a user by email
+     *
+     * @example
+     * ```typescript
+     * const user = await baasix.users.findByEmail('user@example.com');
+     * ```
+     */
+    findByEmail(email: string): Promise<User | null>;
+    /**
+     * Create a new user
+     *
+     * @example
+     * ```typescript
+     * const id = await baasix.users.create({
+     *   email: 'user@example.com',
+     *   password: 'securepassword',
+     *   firstName: 'John',
+     *   lastName: 'Doe',
+     *   role_Id: 'role-uuid'
+     * });
+     * ```
+     */
+    create(data: CreateUserData): Promise<string>;
+    /**
+     * Update a user
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.update('user-uuid', {
+     *   firstName: 'Jane'
+     * });
+     * ```
+     */
+    update(id: string, data: UpdateUserData): Promise<void>;
+    /**
+     * Delete a user
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.delete('user-uuid');
+     * ```
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Change a user's password (admin operation)
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.changePassword('user-uuid', 'newpassword');
+     * ```
+     */
+    changePassword(userId: string, newPassword: string): Promise<void>;
+    /**
+     * Suspend a user
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.suspend('user-uuid');
+     * ```
+     */
+    suspend(id: string): Promise<void>;
+    /**
+     * Activate a user
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.activate('user-uuid');
+     * ```
+     */
+    activate(id: string): Promise<void>;
+    /**
+     * Bulk create users
+     *
+     * @example
+     * ```typescript
+     * const ids = await baasix.users.createMany([
+     *   { email: 'user1@example.com', firstName: 'User 1' },
+     *   { email: 'user2@example.com', firstName: 'User 2' }
+     * ]);
+     * ```
+     */
+    createMany(users: CreateUserData[]): Promise<string[]>;
+    /**
+     * Bulk delete users
+     *
+     * @example
+     * ```typescript
+     * await baasix.users.deleteMany(['user-uuid-1', 'user-uuid-2']);
+     * ```
+     */
+    deleteMany(ids: string[]): Promise<void>;
+}
+
+interface MigrationsModuleConfig {
+    client: HttpClient;
+}
+interface MigrationStatus {
+    lastBatch: number;
+    totalMigrations: number;
+    pendingCount: number;
+    completedCount: number;
+    hasPending: boolean;
+}
+interface Migration {
+    id: string;
+    name: string;
+    batch: number;
+    migratedAt: string;
+}
+interface PendingMigration {
+    name: string;
+    path?: string;
+}
+interface MigrationResult {
+    success: boolean;
+    migrationsRun: string[];
+    errors?: string[];
+}
+interface RollbackResult {
+    success: boolean;
+    migrationsRolledBack: string[];
+    errors?: string[];
+}
+/**
+ * Migrations module for managing database schema migrations.
+ * Admin access required for all operations.
+ *
+ * @example
+ * ```typescript
+ * // Check migration status
+ * const status = await baasix.migrations.status();
+ *
+ * // Run pending migrations
+ * if (status.hasPending) {
+ *   await baasix.migrations.run();
+ * }
+ * ```
+ */
+declare class MigrationsModule {
+    private client;
+    constructor(config: MigrationsModuleConfig);
+    /**
+     * Get migration status
+     *
+     * @example
+     * ```typescript
+     * const status = await baasix.migrations.status();
+     * console.log(`Pending migrations: ${status.pendingCount}`);
+     * ```
+     */
+    status(): Promise<MigrationStatus>;
+    /**
+     * Get all completed migrations
+     *
+     * @example
+     * ```typescript
+     * const migrations = await baasix.migrations.list();
+     * ```
+     */
+    list(): Promise<Migration[]>;
+    /**
+     * Get pending migrations
+     *
+     * @example
+     * ```typescript
+     * const pending = await baasix.migrations.pending();
+     * ```
+     */
+    pending(): Promise<PendingMigration[]>;
+    /**
+     * Check if there are pending migrations
+     *
+     * @example
+     * ```typescript
+     * const needsMigration = await baasix.migrations.hasPending();
+     * ```
+     */
+    hasPending(): Promise<boolean>;
+    /**
+     * Get a specific migration by name
+     *
+     * @example
+     * ```typescript
+     * const migration = await baasix.migrations.get('20231201_create_users');
+     * ```
+     */
+    get(name: string): Promise<Migration | null>;
+    /**
+     * Run pending migrations
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.migrations.run();
+     * console.log(`Ran ${result.migrationsRun.length} migrations`);
+     * ```
+     */
+    run(): Promise<MigrationResult>;
+    /**
+     * Rollback a specific migration
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.migrations.rollback('20231201_create_users');
+     * ```
+     */
+    rollback(name: string): Promise<RollbackResult>;
+    /**
+     * Rollback the last batch of migrations
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.migrations.rollbackLast();
+     * ```
+     */
+    rollbackLast(): Promise<RollbackResult>;
+    /**
+     * Create a new migration file
+     *
+     * @example
+     * ```typescript
+     * const migrationName = await baasix.migrations.create('add_status_column');
+     * ```
+     */
+    create(name: string): Promise<string>;
+    /**
+     * Mark a migration as complete (without running it)
+     *
+     * @example
+     * ```typescript
+     * await baasix.migrations.markComplete('20231201_create_users');
+     * ```
+     */
+    markComplete(name: string): Promise<void>;
+    /**
+     * Mark all pending migrations as complete
+     *
+     * @example
+     * ```typescript
+     * await baasix.migrations.markAllComplete();
+     * ```
+     */
+    markAllComplete(): Promise<void>;
+}
+
+/**
+ * The main Baasix SDK client.
+ *
+ * @example
+ * ```typescript
+ * import { createBaasix } from '@baasix/sdk';
+ *
+ * // Basic setup
+ * const baasix = createBaasix({
+ *   url: 'https://api.example.com'
+ * });
+ *
+ * // With custom storage (React Native)
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * import { AsyncStorageAdapter } from '@baasix/sdk';
+ *
+ * const baasix = createBaasix({
+ *   url: 'https://api.example.com',
+ *   storage: new AsyncStorageAdapter(AsyncStorage)
+ * });
+ *
+ * // Cookie mode (for web apps with HTTP-only cookies)
+ * const baasix = createBaasix({
+ *   url: 'https://api.example.com',
+ *   authMode: 'cookie'
+ * });
+ *
+ * // Server-side with static token
+ * const baasix = createBaasix({
+ *   url: 'https://api.example.com',
+ *   token: 'your-api-token'
+ * });
+ * ```
+ */
+declare class Baasix {
+    private config;
+    private httpClient;
+    private storage;
+    readonly auth: AuthModule;
+    readonly files: FilesModule;
+    readonly schemas: SchemasModule;
+    readonly notifications: NotificationsModule;
+    readonly permissions: PermissionsModule;
+    readonly settings: SettingsModule;
+    readonly reports: ReportsModule;
+    readonly workflows: WorkflowsModule;
+    readonly realtime: RealtimeModule;
+    readonly roles: RolesModule;
+    readonly users: UsersModule;
+    readonly migrations: MigrationsModule;
+    private itemsModules;
+    constructor(config: BaasixConfig);
+    /**
+     * Get an Items module for a specific collection.
+     * Returns a cached instance for repeated calls with the same collection.
+     *
+     * @example
+     * ```typescript
+     * // Get items module
+     * const products = baasix.items('products');
+     *
+     * // CRUD operations
+     * const { data } = await products.find({ filter: { status: { eq: 'active' } } });
+     * const product = await products.findOne('product-uuid');
+     * const id = await products.create({ name: 'New Product', price: 29.99 });
+     * await products.update('product-uuid', { price: 24.99 });
+     * await products.delete('product-uuid');
+     *
+     * // Query builder
+     * const results = await baasix.items('posts')
+     *   .query()
+     *   .select('*', 'author.*')
+     *   .filter({ status: { eq: 'published' } })
+     *   .sort({ createdAt: 'desc' })
+     *   .limit(10)
+     *   .get();
+     * ```
+     */
+    items<T extends BaseItem = BaseItem>(collection: string): ItemsModule<T>;
+    /**
+     * Alias for items() - get a collection
+     *
+     * @example
+     * ```typescript
+     * const products = baasix.collection('products');
+     * ```
+     */
+    collection<T extends BaseItem = BaseItem>(collection: string): ItemsModule<T>;
+    /**
+     * Alias for items() - from a collection (Supabase-style)
+     *
+     * @example
+     * ```typescript
+     * const products = baasix.from('products');
+     * ```
+     */
+    from<T extends BaseItem = BaseItem>(collection: string): ItemsModule<T>;
+    /**
+     * Get the underlying HTTP client for custom requests
+     *
+     * @example
+     * ```typescript
+     * // Custom GET request
+     * const data = await baasix.request.get('/custom-endpoint');
+     *
+     * // Custom POST request
+     * const result = await baasix.request.post('/custom-endpoint', { data: 'value' });
+     * ```
+     */
+    get request(): HttpClient;
+    /**
+     * Update SDK configuration
+     *
+     * @example
+     * ```typescript
+     * baasix.configure({
+     *   headers: { 'X-Custom-Header': 'value' }
+     * });
+     * ```
+     */
+    configure(config: Partial<BaasixConfig>): void;
+    /**
+     * Set the tenant for multi-tenant mode
+     *
+     * @example
+     * ```typescript
+     * baasix.setTenant('tenant-uuid');
+     * ```
+     */
+    setTenant(tenantId: string): Promise<void>;
+    /**
+     * Get the current tenant ID
+     */
+    getTenant(): Promise<string | null>;
+    /**
+     * Clear the tenant
+     */
+    clearTenant(): Promise<void>;
+    /**
+     * Get the base URL
+     */
+    getUrl(): string;
+    /**
+     * Get the current auth mode
+     */
+    getAuthMode(): AuthMode;
+    /**
+     * Get the storage adapter
+     */
+    getStorage(): StorageAdapter;
+}
+/**
+ * Create a new Baasix SDK instance.
+ *
+ * @example
+ * ```typescript
+ * import { createBaasix } from '@baasix/sdk';
+ *
+ * const baasix = createBaasix({
+ *   url: 'https://api.example.com',
+ *   authMode: 'jwt', // or 'cookie'
+ *   onAuthStateChange: (event, user) => {
+ *     console.log('Auth state changed:', event, user);
+ *   }
+ * });
+ *
+ * // Initialize on app startup
+ * await baasix.auth.initialize();
+ *
+ * // Check if user is authenticated
+ * if (await baasix.auth.isAuthenticated()) {
+ *   const user = await baasix.auth.getUser();
+ *   console.log('Logged in as:', user?.email);
+ * }
+ * ```
+ */
+declare function createBaasix(config: BaasixConfig): Baasix;
+
+export { Aggregate, AuthMode, AuthModule, Baasix, BaasixConfig, BaseItem, CreatePermissionData, type CreateRoleData, type CreateUserData, FilesModule, Filter, HttpClient, ItemsModule, type Migration, type MigrationResult, type MigrationStatus, MigrationsModule, Notification, NotificationsModule, PaginatedResponse, type PendingMigration, Permission, PermissionsModule, RealtimeChannel, type RealtimeConfig, RealtimeModule, ReportConfig, ReportResult, ReportsModule, type Role, RolesModule, type RollbackResult, SchemasModule, SendNotificationData, Settings, SettingsModule, StorageAdapter, type SubscriptionCallback, type SubscriptionEvent, type SubscriptionPayload, type UpdateUserData, type UserQueryOptions, UsersModule, Workflow, WorkflowExecution, type WorkflowExecutionUpdate, WorkflowsModule, createBaasix };