@baasix/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1788 @@
+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-DeXa-R9w.js';
+export { V as AggregateConfig, O as AggregateFunction, k as AssetTransformOptions, b as AuthResponse, d as AuthState, a as AuthStateEvent, c as AuthTokens, a4 as BaasixError, a3 as BaasixErrorDetails, f as BulkResponse, a6 as CollectionItem, a5 as DeepPartial, Y as DefaultValueType, D as DeleteResponse, Z 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, _ 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, a2 as WorkflowEdge, a1 as WorkflowNode, a0 as WorkflowTrigger } from './client-DeXa-R9w.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;
+        filter?: Record<string, unknown>;
+    }): Promise<PaginatedResponse<Notification>>;
+    /**
+     * Get unread notification count
+     *
+     * @example
+     * ```typescript
+     * const count = await baasix.notifications.getUnreadCount();
+     * ```
+     */
+    getUnreadCount(): Promise<number>;
+    /**
+     * Mark notifications as seen
+     *
+     * @example
+     * ```typescript
+     * // Mark specific notifications as seen
+     * await baasix.notifications.markAsSeen(['id1', 'id2']);
+     *
+     * // Mark all notifications as seen
+     * await baasix.notifications.markAsSeen();
+     * ```
+     */
+    markAsSeen(notificationIds?: string[]): Promise<{
+        count: number;
+    }>;
+    /**
+     * Delete notifications for the current user
+     *
+     * @example
+     * ```typescript
+     * // Delete specific notifications
+     * await baasix.notifications.delete(['id1', 'id2']);
+     *
+     * // Delete all notifications
+     * await baasix.notifications.delete();
+     * ```
+     */
+    delete(notificationIds?: string[]): Promise<{
+        count: number;
+    }>;
+    /**
+     * 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<{
+        notificationIds: string[];
+    }>;
+    /**
+     * Cleanup old notifications (requires admin permissions)
+     *
+     * @example
+     * ```typescript
+     * // Clean up notifications older than 30 days (default)
+     * await baasix.notifications.cleanup();
+     *
+     * // Clean up notifications older than 7 days
+     * await baasix.notifications.cleanup(7);
+     * ```
+     */
+    cleanup(days?: number): Promise<{
+        count: number;
+    }>;
+}
+
+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;
+}
+/**
+ * Stats query for the stats endpoint
+ */
+interface StatsQuery {
+    /** Unique name for this stats query */
+    name: string;
+    /** Collection to query */
+    collection: string;
+    /** Query parameters including aggregate, groupBy, filter, fields */
+    query: {
+        aggregate?: Aggregate;
+        groupBy?: string[];
+        filter?: Filter;
+        fields?: string[];
+    };
+}
+/**
+ * Stats result from a single query
+ */
+interface StatsResult {
+    name: string;
+    collection: string;
+    data: Record<string, unknown>[];
+}
+/**
+ * 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 using POST method
+     *
+     * @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>;
+    /**
+     * Query a report for a collection using GET method with query params
+     *
+     * @example
+     * ```typescript
+     * const report = await baasix.reports.query('orders', {
+     *   aggregate: {
+     *     total: { function: 'sum', field: 'amount' }
+     *   },
+     *   groupBy: ['status']
+     * });
+     * ```
+     */
+    query(collection: string, params?: {
+        aggregate?: Aggregate;
+        groupBy?: string[];
+        filter?: Filter;
+        fields?: string[];
+    }): Promise<ReportResult>;
+    /**
+     * Get statistics for multiple collections in a single request
+     *
+     * @example
+     * ```typescript
+     * const stats = await baasix.reports.getStats([
+     *   {
+     *     name: 'total_products',
+     *     collection: 'products',
+     *     query: {
+     *       aggregate: { count: { function: 'count', field: '*' } }
+     *     }
+     *   },
+     *   {
+     *     name: 'total_orders',
+     *     collection: 'orders',
+     *     query: {
+     *       aggregate: {
+     *         count: { function: 'count', field: '*' },
+     *         total_amount: { function: 'sum', field: 'amount' }
+     *       }
+     *     }
+     *   }
+     * ]);
+     * ```
+     */
+    getStats(stats: StatsQuery[]): Promise<StatsResult[]>;
+    /**
+     * 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 RoomMessage {
+    room: string;
+    event: string;
+    payload: any;
+    sender: {
+        userId: string | number;
+        socketId: string;
+    };
+    timestamp: string;
+}
+interface RoomUserEvent {
+    room: string;
+    userId: string | number;
+    socketId: 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 roomCallbacks;
+    private roomUserCallbacks;
+    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;
+    /**
+     * Join a custom room for real-time communication
+     *
+     * @example
+     * ```typescript
+     * // Join a room
+     * await baasix.realtime.joinRoom('game:lobby');
+     *
+     * // Listen for messages
+     * baasix.realtime.onRoomMessage('game:lobby', 'chat', (data) => {
+     *   console.log(`${data.sender.userId}: ${data.payload.text}`);
+     * });
+     * ```
+     */
+    joinRoom(roomName: string): Promise<void>;
+    /**
+     * Leave a custom room
+     *
+     * @example
+     * ```typescript
+     * await baasix.realtime.leaveRoom('game:lobby');
+     * ```
+     */
+    leaveRoom(roomName: string): Promise<void>;
+    /**
+     * Send a message to a room
+     *
+     * @example
+     * ```typescript
+     * // Send a chat message
+     * await baasix.realtime.sendToRoom('game:lobby', 'chat', { text: 'Hello!' });
+     *
+     * // Send a game event
+     * await baasix.realtime.sendToRoom('game:123', 'move', { x: 10, y: 20 });
+     * ```
+     */
+    sendToRoom(roomName: string, event: string, payload: any): Promise<void>;
+    /**
+     * Listen for messages in a room with a specific event type
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.onRoomMessage('game:lobby', 'chat', (data) => {
+     *   console.log(`${data.sender.userId}: ${data.payload.text}`);
+     * });
+     *
+     * // Later
+     * unsubscribe();
+     * ```
+     */
+    onRoomMessage(roomName: string, event: string, callback: (data: RoomMessage) => void): () => void;
+    /**
+     * Listen for users joining a room
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.onRoomUserJoined('game:lobby', (data) => {
+     *   console.log(`User ${data.userId} joined the room`);
+     * });
+     * ```
+     */
+    onRoomUserJoined(roomName: string, callback: (data: RoomUserEvent) => void): () => void;
+    /**
+     * Listen for users leaving a room
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = baasix.realtime.onRoomUserLeft('game:lobby', (data) => {
+     *   console.log(`User ${data.userId} left the room`);
+     * });
+     * ```
+     */
+    onRoomUserLeft(roomName: string, callback: (data: RoomUserEvent) => void): () => void;
+    /**
+     * Invoke a custom server-side handler
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.realtime.invoke('game:roll-dice', { sides: 6 });
+     * console.log('Dice result:', result);
+     * ```
+     */
+    invoke<T = any>(event: string, payload: any): Promise<T>;
+    private setupRoomListeners;
+    private cleanupRoomListeners;
+    /**
+     * 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;
+    version: string;
+    name: string;
+    type: string;
+    status: string;
+    batch: number;
+    migratedAt: string;
+    executionTime?: number;
+}
+interface PendingMigration {
+    version: string;
+    name: string;
+    type: string;
+    path?: string;
+}
+interface MigrationRunOptions {
+    /** Run only a specific migration version */
+    version?: string;
+    /** Run migrations up to and including this version */
+    toVersion?: string;
+    /** Number of migrations to run */
+    step?: number;
+    /** Preview without executing */
+    dryRun?: boolean;
+}
+interface MigrationRunResult {
+    results: Array<{
+        version: string;
+        name: string;
+        status: "completed" | "failed";
+        error?: string;
+    }>;
+    summary: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+}
+interface RollbackResult {
+    results: Array<{
+        version: string;
+        name: string;
+        status: string;
+    }>;
+    summary: {
+        total: number;
+    };
+}
+interface CreateMigrationOptions {
+    /** Migration type (system, schema, data, custom) */
+    type?: "system" | "schema" | "data" | "custom";
+    /** Migration description */
+    description?: string;
+    /** Custom version (auto-generated if not provided) */
+    version?: 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 migrations with optional filtering
+     *
+     * @example
+     * ```typescript
+     * // Get all migrations
+     * const migrations = await baasix.migrations.list();
+     *
+     * // Get completed migrations
+     * const completed = await baasix.migrations.list({ status: 'completed' });
+     * ```
+     */
+    list(options?: {
+        status?: "pending" | "completed" | "failed";
+        type?: "system" | "schema" | "data" | "custom";
+    }): Promise<Migration[]>;
+    /**
+     * Get pending migrations
+     *
+     * @example
+     * ```typescript
+     * const pending = await baasix.migrations.pending();
+     * ```
+     */
+    pending(): Promise<PendingMigration[]>;
+    /**
+     * Check if migrations are needed
+     *
+     * @example
+     * ```typescript
+     * const check = await baasix.migrations.check();
+     * if (check.hasPending) {
+     *   console.log('Migrations needed');
+     * }
+     * ```
+     */
+    check(): Promise<{
+        hasPending: boolean;
+        pendingCount: number;
+    }>;
+    /**
+     * Get a specific migration by version
+     *
+     * @example
+     * ```typescript
+     * const migration = await baasix.migrations.get('20231201000000');
+     * ```
+     */
+    get(version: string): Promise<Migration | null>;
+    /**
+     * Run pending migrations
+     *
+     * @example
+     * ```typescript
+     * // Run all pending migrations
+     * const result = await baasix.migrations.run();
+     *
+     * // Run with options
+     * const result = await baasix.migrations.run({
+     *   step: 1,  // Run only 1 migration
+     *   dryRun: true  // Preview without executing
+     * });
+     * ```
+     */
+    run(options?: MigrationRunOptions): Promise<MigrationRunResult>;
+    /**
+     * Rollback a specific migration
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.migrations.rollback('20231201000000');
+     * ```
+     */
+    rollback(version: string): Promise<RollbackResult>;
+    /**
+     * Rollback the last batch of migrations
+     *
+     * @example
+     * ```typescript
+     * const result = await baasix.migrations.rollbackBatch();
+     * ```
+     */
+    rollbackBatch(): Promise<RollbackResult>;
+    /**
+     * Create a new migration file
+     *
+     * @example
+     * ```typescript
+     * const { filepath } = await baasix.migrations.create('add_status_column', {
+     *   type: 'schema',
+     *   description: 'Add status column to orders'
+     * });
+     * ```
+     */
+    create(name: string, options?: CreateMigrationOptions): Promise<{
+        filepath: string;
+    }>;
+    /**
+     * Mark a specific migration as completed without running it
+     * Useful for existing installations that already have the changes
+     *
+     * @example
+     * ```typescript
+     * await baasix.migrations.markCompleted('20231201000000');
+     * ```
+     */
+    markCompleted(version: string, metadata?: Record<string, unknown>): Promise<Migration>;
+    /**
+     * Mark all pending migrations as completed
+     * Useful for bringing an existing database up to date without running migrations
+     *
+     * @example
+     * ```typescript
+     * // Mark all pending
+     * await baasix.migrations.markAllCompleted();
+     *
+     * // Mark up to a specific version
+     * await baasix.migrations.markAllCompleted('20231201000000');
+     * ```
+     */
+    markAllCompleted(toVersion?: string): Promise<MigrationRunResult>;
+}
+
+interface ServerInfo {
+    project?: {
+        name?: string;
+        multitenant?: boolean | string;
+        [key: string]: unknown;
+    };
+    version?: string;
+    [key: string]: unknown;
+}
+interface ServerModuleConfig {
+    client: HttpClient;
+}
+/**
+ * Server module for retrieving server information.
+ *
+ * @example
+ * ```typescript
+ * const info = await baasix.server.info();
+ * console.log(info.project?.name);
+ * ```
+ */
+declare class ServerModule {
+    private client;
+    constructor(config: ServerModuleConfig);
+    /**
+     * Get server information including project settings
+     *
+     * @example
+     * ```typescript
+     * const info = await baasix.server.info();
+     * console.log('Project:', info.project?.name);
+     * console.log('Version:', info.version);
+     * ```
+     */
+    info(): Promise<ServerInfo>;
+    /**
+     * Check server health
+     *
+     * @example
+     * ```typescript
+     * const isHealthy = await baasix.server.health();
+     * ```
+     */
+    health(): Promise<boolean>;
+}
+
+/**
+ * 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;
+    readonly server: ServerModule;
+    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>;
+    /**
+     * Set a static token (convenience method that delegates to auth.setToken)
+     *
+     * @example
+     * ```typescript
+     * baasix.setToken('your-api-token');
+     * ```
+     */
+    setToken(token: string): Promise<void>;
+    /**
+     * Get the current auth token
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * 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, type CreateMigrationOptions, CreatePermissionData, type CreateRoleData, type CreateUserData, FilesModule, Filter, HttpClient, ItemsModule, type Migration, type MigrationRunOptions, type MigrationRunResult, 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, type StatsQuery, type StatsResult, StorageAdapter, type SubscriptionCallback, type SubscriptionEvent, type SubscriptionPayload, type UpdateUserData, type UserQueryOptions, UsersModule, Workflow, WorkflowExecution, type WorkflowExecutionUpdate, WorkflowsModule, createBaasix };