@baasix/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4567 @@
+'use strict';
+
+// src/storage/types.ts
+var STORAGE_KEYS = {
+  ACCESS_TOKEN: "baasix_access_token",
+  REFRESH_TOKEN: "baasix_refresh_token",
+  TOKEN_EXPIRY: "baasix_token_expiry",
+  USER: "baasix_user",
+  TENANT: "baasix_tenant"
+};
+
+// src/types.ts
+var BaasixError = class _BaasixError extends Error {
+  status;
+  code;
+  details;
+  isRetryable;
+  constructor(message, status = 500, code, details) {
+    super(message);
+    this.name = "BaasixError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.isRetryable = status >= 500 || status === 429;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BaasixError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+
+// src/client.ts
+var HttpClient = class {
+  config;
+  refreshPromise = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get the current base URL
+   */
+  getBaseUrl() {
+    return this.config.baseUrl;
+  }
+  /**
+   * Build the full URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(path, this.config.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          if (typeof value === "object") {
+            url.searchParams.set(key, JSON.stringify(value));
+          } else {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Get the current access token
+   */
+  async getAccessToken() {
+    if (this.config.token) {
+      return this.config.token;
+    }
+    if (this.config.authMode === "cookie") {
+      return null;
+    }
+    const token = await this.config.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+    return token;
+  }
+  /**
+   * Check if token is expired or about to expire (within 60 seconds)
+   */
+  async isTokenExpired() {
+    const expiry = await this.config.storage.get(STORAGE_KEYS.TOKEN_EXPIRY);
+    if (!expiry) return false;
+    const expiryTime = parseInt(expiry, 10);
+    const bufferTime = 60 * 1e3;
+    return Date.now() >= expiryTime - bufferTime;
+  }
+  /**
+   * Refresh the access token
+   */
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = (async () => {
+      try {
+        const refreshToken = await this.config.storage.get(
+          STORAGE_KEYS.REFRESH_TOKEN
+        );
+        if (!refreshToken && this.config.authMode === "jwt") {
+          throw new BaasixError("No refresh token available", 401, "NO_REFRESH_TOKEN");
+        }
+        const response = await fetch(
+          this.buildUrl("/auth/refresh"),
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...this.config.headers
+            },
+            body: this.config.authMode === "jwt" ? JSON.stringify({ refreshToken }) : void 0,
+            credentials: this.config.credentials
+          }
+        );
+        if (!response.ok) {
+          throw new BaasixError("Token refresh failed", response.status, "REFRESH_FAILED");
+        }
+        const data = await response.json();
+        const tokens = {
+          accessToken: data.token,
+          refreshToken: data.refreshToken,
+          expiresIn: data.expiresIn,
+          expiresAt: data.expiresIn ? Date.now() + data.expiresIn * 1e3 : void 0
+        };
+        await this.config.storage.set(STORAGE_KEYS.ACCESS_TOKEN, tokens.accessToken);
+        if (tokens.refreshToken) {
+          await this.config.storage.set(STORAGE_KEYS.REFRESH_TOKEN, tokens.refreshToken);
+        }
+        if (tokens.expiresAt) {
+          await this.config.storage.set(
+            STORAGE_KEYS.TOKEN_EXPIRY,
+            tokens.expiresAt.toString()
+          );
+        }
+        this.config.onTokenRefresh?.(tokens);
+        return tokens;
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  /**
+   * Build request headers
+   */
+  async buildHeaders(options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.tenantId) {
+      headers["X-Tenant-Id"] = this.config.tenantId;
+    }
+    if (options.skipAuth) {
+      return headers;
+    }
+    if (this.config.authMode === "jwt") {
+      if (this.config.autoRefresh && await this.isTokenExpired()) {
+        try {
+          await this.refreshToken();
+        } catch {
+        }
+      }
+      const token = await this.getAccessToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Parse error response
+   */
+  async parseError(response) {
+    let errorData = {};
+    try {
+      errorData = await response.json();
+    } catch {
+    }
+    const message = errorData.error?.message || errorData.message || response.statusText || "Request failed";
+    const code = errorData.error?.code;
+    const details = errorData.details;
+    return new BaasixError(message, response.status, code, details);
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(method, path, options = {}) {
+    const { params, timeout, skipAuth, rawResponse, ...fetchOptions } = options;
+    const url = this.buildUrl(path, params);
+    const headers = await this.buildHeaders({ skipAuth });
+    const requestTimeout = timeout || this.config.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          ...headers,
+          ...fetchOptions.headers
+        },
+        credentials: this.config.credentials,
+        signal: controller.signal,
+        ...fetchOptions
+      });
+      if (response.status === 401 && !skipAuth && this.config.autoRefresh) {
+        try {
+          await this.refreshToken();
+          const retryHeaders = await this.buildHeaders({ skipAuth: false });
+          const retryResponse = await fetch(url, {
+            method,
+            headers: {
+              ...retryHeaders,
+              ...fetchOptions.headers
+            },
+            credentials: this.config.credentials,
+            ...fetchOptions
+          });
+          if (!retryResponse.ok) {
+            throw await this.parseError(retryResponse);
+          }
+          if (rawResponse) {
+            return retryResponse;
+          }
+          if (retryResponse.status === 204) {
+            return {};
+          }
+          return await retryResponse.json();
+        } catch (refreshError) {
+          this.config.onAuthError?.();
+          throw refreshError;
+        }
+      }
+      if (!response.ok) {
+        throw await this.parseError(response);
+      }
+      if (rawResponse) {
+        return response;
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof BaasixError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new BaasixError("Request timeout", 408, "TIMEOUT");
+        }
+        throw new BaasixError(error.message, 0, "NETWORK_ERROR");
+      }
+      throw new BaasixError("Unknown error occurred", 500, "UNKNOWN");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * GET request
+   */
+  get(path, options) {
+    return this.request("GET", path, options);
+  }
+  /**
+   * POST request
+   */
+  post(path, data, options) {
+    return this.request("POST", path, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * PATCH request
+   */
+  patch(path, data, options) {
+    return this.request("PATCH", path, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * PUT request
+   */
+  put(path, data, options) {
+    return this.request("PUT", path, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * DELETE request
+   */
+  delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  /**
+   * Upload file with multipart/form-data
+   */
+  async upload(path, formData, options) {
+    const { params, timeout, skipAuth, onProgress } = options || {};
+    const url = this.buildUrl(path, params);
+    const headers = await this.buildHeaders({ skipAuth });
+    const requestTimeout = timeout || this.config.timeout;
+    delete headers["Content-Type"];
+    if (onProgress && typeof XMLHttpRequest !== "undefined") {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("POST", url);
+        Object.entries(headers).forEach(
+          ([key, value]) => {
+            xhr.setRequestHeader(key, value);
+          }
+        );
+        xhr.withCredentials = this.config.credentials === "include";
+        xhr.upload.onprogress = (event) => {
+          if (event.lengthComputable) {
+            const progress = Math.round(event.loaded / event.total * 100);
+            onProgress(progress);
+          }
+        };
+        xhr.onload = () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              resolve(JSON.parse(xhr.responseText));
+            } catch {
+              resolve({});
+            }
+          } else {
+            reject(
+              new BaasixError(
+                xhr.statusText || "Upload failed",
+                xhr.status,
+                "UPLOAD_ERROR"
+              )
+            );
+          }
+        };
+        xhr.onerror = () => {
+          reject(new BaasixError("Network error during upload", 0, "NETWORK_ERROR"));
+        };
+        xhr.ontimeout = () => {
+          reject(new BaasixError("Upload timeout", 408, "TIMEOUT"));
+        };
+        xhr.timeout = requestTimeout;
+        xhr.send(formData);
+      });
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: formData,
+        credentials: this.config.credentials,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw await this.parseError(response);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/storage/localStorage.ts
+var LocalStorageAdapter = class {
+  prefix;
+  constructor(prefix = "baasix_") {
+    this.prefix = prefix;
+  }
+  getKey(key) {
+    if (key.startsWith(this.prefix)) {
+      return key;
+    }
+    return `${this.prefix}${key}`;
+  }
+  get(key) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return null;
+    }
+    try {
+      return localStorage.getItem(this.getKey(key));
+    } catch {
+      console.warn(`[Baasix SDK] Failed to get item from localStorage: ${key}`);
+      return null;
+    }
+  }
+  set(key, value) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      localStorage.setItem(this.getKey(key), value);
+    } catch {
+      console.warn(`[Baasix SDK] Failed to set item in localStorage: ${key}`);
+    }
+  }
+  remove(key) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      localStorage.removeItem(this.getKey(key));
+    } catch {
+      console.warn(`[Baasix SDK] Failed to remove item from localStorage: ${key}`);
+    }
+  }
+  clear() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => localStorage.removeItem(key));
+    } catch {
+      console.warn("[Baasix SDK] Failed to clear localStorage");
+    }
+  }
+};
+
+// src/storage/memoryStorage.ts
+var MemoryStorageAdapter = class {
+  store;
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    return this.store.get(key) ?? null;
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  remove(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  /**
+   * Get all stored keys (useful for debugging)
+   */
+  keys() {
+    return Array.from(this.store.keys());
+  }
+  /**
+   * Get the number of stored items
+   */
+  size() {
+    return this.store.size;
+  }
+};
+
+// src/modules/auth.ts
+var AuthModule = class {
+  client;
+  storage;
+  authMode;
+  onAuthStateChange;
+  currentUser = null;
+  constructor(config) {
+    this.client = config.client;
+    this.storage = config.storage;
+    this.authMode = config.authMode;
+    this.onAuthStateChange = config.onAuthStateChange;
+  }
+  /**
+   * Emit an authentication state change event
+   */
+  emitAuthStateChange(event, user) {
+    this.currentUser = user;
+    this.onAuthStateChange?.(event, user);
+  }
+  /**
+   * Store authentication tokens
+   */
+  async storeTokens(response) {
+    if (this.authMode === "jwt") {
+      await this.storage.set(STORAGE_KEYS.ACCESS_TOKEN, response.token);
+      if (response.refreshToken) {
+        await this.storage.set(STORAGE_KEYS.REFRESH_TOKEN, response.refreshToken);
+      }
+      if (response.expiresIn) {
+        const expiresAt = Date.now() + response.expiresIn * 1e3;
+        await this.storage.set(STORAGE_KEYS.TOKEN_EXPIRY, expiresAt.toString());
+      }
+    }
+    if (response.user) {
+      await this.storage.set(STORAGE_KEYS.USER, JSON.stringify(response.user));
+    }
+  }
+  /**
+   * Clear stored authentication data
+   */
+  async clearAuth() {
+    await this.storage.remove(STORAGE_KEYS.ACCESS_TOKEN);
+    await this.storage.remove(STORAGE_KEYS.REFRESH_TOKEN);
+    await this.storage.remove(STORAGE_KEYS.TOKEN_EXPIRY);
+    await this.storage.remove(STORAGE_KEYS.USER);
+    await this.storage.remove(STORAGE_KEYS.TENANT);
+    this.currentUser = null;
+  }
+  /**
+   * Register a new user
+   *
+   * @example
+   * ```typescript
+   * const { user, token } = await baasix.auth.register({
+   *   email: 'newuser@example.com',
+   *   password: 'securepassword',
+   *   firstName: 'John',
+   *   lastName: 'Doe'
+   * });
+   * ```
+   */
+  async register(data) {
+    const response = await this.client.post("/auth/register", data, {
+      skipAuth: true
+    });
+    await this.storeTokens(response);
+    this.emitAuthStateChange("SIGNED_IN", response.user);
+    return response;
+  }
+  /**
+   * Login with email and password
+   *
+   * @example
+   * ```typescript
+   * const { user, token } = await baasix.auth.login({
+   *   email: 'user@example.com',
+   *   password: 'password123'
+   * });
+   *
+   * // Login with tenant (multi-tenant mode)
+   * const result = await baasix.auth.login({
+   *   email: 'user@example.com',
+   *   password: 'password123',
+   *   tenantId: 'tenant-uuid'
+   * });
+   * ```
+   */
+  async login(credentials) {
+    const response = await this.client.post(
+      "/auth/login",
+      {
+        email: credentials.email,
+        password: credentials.password,
+        tenant_Id: credentials.tenantId
+      },
+      { skipAuth: true }
+    );
+    await this.storeTokens(response);
+    this.emitAuthStateChange("SIGNED_IN", response.user);
+    return response;
+  }
+  /**
+   * Logout the current user
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.logout();
+   * ```
+   */
+  async logout() {
+    try {
+      await this.client.get("/auth/logout");
+    } catch {
+    }
+    await this.clearAuth();
+    this.emitAuthStateChange("SIGNED_OUT", null);
+  }
+  /**
+   * Get the current authenticated user from the server
+   *
+   * @example
+   * ```typescript
+   * const user = await baasix.auth.getUser();
+   * console.log(user?.email);
+   * ```
+   */
+  async getUser() {
+    try {
+      const response = await this.client.get("/auth/me");
+      this.currentUser = response.data;
+      await this.storage.set(STORAGE_KEYS.USER, JSON.stringify(response.data));
+      return response.data;
+    } catch (error) {
+      if (error instanceof BaasixError && error.status === 401) {
+        await this.clearAuth();
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get the cached current user (does not make an API call)
+   *
+   * @example
+   * ```typescript
+   * const user = await baasix.auth.getCachedUser();
+   * ```
+   */
+  async getCachedUser() {
+    if (this.currentUser) {
+      return this.currentUser;
+    }
+    const userJson = await this.storage.get(STORAGE_KEYS.USER);
+    if (userJson) {
+      try {
+        this.currentUser = JSON.parse(userJson);
+        return this.currentUser;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if user is authenticated (has valid token)
+   *
+   * @example
+   * ```typescript
+   * if (await baasix.auth.isAuthenticated()) {
+   *   // User is logged in
+   * }
+   * ```
+   */
+  async isAuthenticated() {
+    if (this.authMode === "cookie") {
+      const user = await this.getCachedUser();
+      return user !== null;
+    }
+    const token = await this.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+    if (!token) return false;
+    const expiry = await this.storage.get(STORAGE_KEYS.TOKEN_EXPIRY);
+    if (expiry && Date.now() >= parseInt(expiry, 10)) {
+      const refreshToken = await this.storage.get(STORAGE_KEYS.REFRESH_TOKEN);
+      return !!refreshToken;
+    }
+    return true;
+  }
+  /**
+   * Get the current access token
+   *
+   * @example
+   * ```typescript
+   * const token = await baasix.auth.getToken();
+   * ```
+   */
+  async getToken() {
+    if (this.authMode === "cookie") {
+      return null;
+    }
+    return await this.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+  }
+  /**
+   * Set a static token (useful for server-side or service accounts)
+   *
+   * @example
+   * ```typescript
+   * baasix.auth.setToken('your-api-token');
+   * ```
+   */
+  async setToken(token) {
+    await this.storage.set(STORAGE_KEYS.ACCESS_TOKEN, token);
+  }
+  /**
+   * Refresh the current token
+   *
+   * @example
+   * ```typescript
+   * const tokens = await baasix.auth.refreshToken();
+   * ```
+   */
+  async refreshToken() {
+    const refreshToken = await this.storage.get(STORAGE_KEYS.REFRESH_TOKEN);
+    const response = await this.client.post(
+      "/auth/refresh",
+      this.authMode === "jwt" ? { refreshToken } : void 0
+    );
+    await this.storeTokens(response);
+    const tokens = {
+      accessToken: response.token,
+      refreshToken: response.refreshToken,
+      expiresIn: response.expiresIn,
+      expiresAt: response.expiresIn ? Date.now() + response.expiresIn * 1e3 : void 0
+    };
+    this.emitAuthStateChange("TOKEN_REFRESHED", response.user);
+    return tokens;
+  }
+  /**
+   * Request a magic link for passwordless login
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.sendMagicLink({
+   *   email: 'user@example.com',
+   *   redirectUrl: 'https://myapp.com/auth/callback'
+   * });
+   * ```
+   */
+  async sendMagicLink(options) {
+    await this.client.post(
+      "/auth/magiclink",
+      {
+        email: options.email,
+        link: options.redirectUrl,
+        mode: options.mode || "link"
+      },
+      { skipAuth: true }
+    );
+  }
+  /**
+   * Verify magic link/code and complete login
+   *
+   * @example
+   * ```typescript
+   * const { user, token } = await baasix.auth.verifyMagicLink('verification-token');
+   * ```
+   */
+  async verifyMagicLink(token) {
+    const response = await this.client.get(
+      `/auth/magiclink/${encodeURIComponent(token)}`,
+      { skipAuth: true }
+    );
+    await this.storeTokens(response);
+    this.emitAuthStateChange("SIGNED_IN", response.user);
+    return response;
+  }
+  /**
+   * Request a password reset
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.forgotPassword({
+   *   email: 'user@example.com',
+   *   redirectUrl: 'https://myapp.com/reset-password'
+   * });
+   * ```
+   */
+  async forgotPassword(options) {
+    await this.client.post(
+      "/auth/forgot-password",
+      {
+        email: options.email,
+        link: options.redirectUrl
+      },
+      { skipAuth: true }
+    );
+  }
+  /**
+   * Reset password using a reset token
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.resetPassword('reset-token', 'newpassword123');
+   * ```
+   */
+  async resetPassword(token, newPassword) {
+    await this.client.post(
+      "/auth/reset-password",
+      { token, password: newPassword },
+      { skipAuth: true }
+    );
+  }
+  /**
+   * Change the current user's password
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.changePassword('currentPassword', 'newPassword');
+   * ```
+   */
+  async changePassword(currentPassword, newPassword) {
+    await this.client.post("/auth/change-password", {
+      currentPassword,
+      newPassword
+    });
+  }
+  /**
+   * Update the current user's profile
+   *
+   * @example
+   * ```typescript
+   * const updatedUser = await baasix.auth.updateProfile({
+   *   firstName: 'Jane',
+   *   lastName: 'Doe'
+   * });
+   * ```
+   */
+  async updateProfile(data) {
+    const response = await this.client.patch("/auth/me", data);
+    await this.storage.set(STORAGE_KEYS.USER, JSON.stringify(response.data));
+    this.emitAuthStateChange("USER_UPDATED", response.data);
+    return response.data;
+  }
+  /**
+   * Get available tenants for the current user (multi-tenant mode)
+   *
+   * @example
+   * ```typescript
+   * const tenants = await baasix.auth.getTenants();
+   * ```
+   */
+  async getTenants() {
+    const response = await this.client.get("/auth/tenants");
+    return response.data;
+  }
+  /**
+   * Switch to a different tenant (multi-tenant mode)
+   *
+   * @example
+   * ```typescript
+   * const { user, token } = await baasix.auth.switchTenant('tenant-uuid');
+   * ```
+   */
+  async switchTenant(tenantId) {
+    const response = await this.client.post("/auth/switch-tenant", {
+      tenant_Id: tenantId
+    });
+    await this.storeTokens(response);
+    await this.storage.set(STORAGE_KEYS.TENANT, tenantId);
+    this.emitAuthStateChange("TENANT_SWITCHED", response.user);
+    return response;
+  }
+  /**
+   * Get the current authentication state
+   *
+   * @example
+   * ```typescript
+   * const state = await baasix.auth.getState();
+   * console.log(state.isAuthenticated, state.user);
+   * ```
+   */
+  async getState() {
+    const isAuthenticated = await this.isAuthenticated();
+    const user = await this.getCachedUser();
+    return {
+      user,
+      isAuthenticated,
+      isLoading: false,
+      error: null
+    };
+  }
+  /**
+   * Initialize authentication state from storage
+   * Call this on app startup to restore previous session
+   *
+   * @example
+   * ```typescript
+   * await baasix.auth.initialize();
+   * ```
+   */
+  async initialize() {
+    const state = await this.getState();
+    if (state.isAuthenticated && state.user) {
+      this.emitAuthStateChange("SIGNED_IN", state.user);
+    }
+    return state;
+  }
+  // ===================
+  // OAuth / Social Login
+  // ===================
+  /**
+   * Get the OAuth authorization URL for a provider
+   * Redirect the user to this URL to start the OAuth flow
+   * 
+   * @example
+   * ```typescript
+   * const url = baasix.auth.getOAuthUrl({
+   *   provider: 'google',
+   *   redirectUrl: 'https://myapp.com/auth/callback'
+   * });
+   * window.location.href = url;
+   * ```
+   */
+  getOAuthUrl(options) {
+    const baseUrl = this.client.getBaseUrl();
+    const params = new URLSearchParams({
+      redirect_url: options.redirectUrl
+    });
+    if (options.scopes?.length) {
+      params.set("scopes", options.scopes.join(","));
+    }
+    if (options.state) {
+      params.set("state", options.state);
+    }
+    return `${baseUrl}/auth/signin/${options.provider}?${params.toString()}`;
+  }
+  /**
+   * Handle OAuth callback and complete login
+   * Call this from your callback page with the token from URL
+   * 
+   * @example
+   * ```typescript
+   * // In your callback page
+   * const params = new URLSearchParams(window.location.search);
+   * const token = params.get('token');
+   * 
+   * if (token) {
+   *   await baasix.auth.handleOAuthCallback(token);
+   * }
+   * ```
+   */
+  async handleOAuthCallback(token) {
+    await this.storage.set(STORAGE_KEYS.ACCESS_TOKEN, token);
+    const user = await this.getUser();
+    const response = {
+      token,
+      user
+    };
+    this.emitAuthStateChange("SIGNED_IN", user);
+    return response;
+  }
+  // ===================
+  // Email Verification
+  // ===================
+  /**
+   * Request email verification
+   * Sends a verification email to the current user
+   * 
+   * @example
+   * ```typescript
+   * await baasix.auth.requestEmailVerification('https://myapp.com/verify-email');
+   * ```
+   */
+  async requestEmailVerification(redirectUrl) {
+    await this.client.post("/auth/request-verify-email", {
+      link: redirectUrl
+    });
+  }
+  /**
+   * Verify email with token
+   * 
+   * @example
+   * ```typescript
+   * const params = new URLSearchParams(window.location.search);
+   * const token = params.get('token');
+   * 
+   * await baasix.auth.verifyEmail(token);
+   * ```
+   */
+  async verifyEmail(token) {
+    await this.client.get("/auth/verify-email", {
+      params: { token },
+      skipAuth: true
+    });
+  }
+  /**
+   * Check if current session/token is valid
+   * 
+   * @example
+   * ```typescript
+   * const isValid = await baasix.auth.checkSession();
+   * ```
+   */
+  async checkSession() {
+    try {
+      const response = await this.client.get("/auth/check");
+      return response.data.valid;
+    } catch {
+      return false;
+    }
+  }
+  // ===================
+  // Invitation System
+  // ===================
+  /**
+   * Send an invitation to a user (multi-tenant mode)
+   * 
+   * @example
+   * ```typescript
+   * await baasix.auth.sendInvite({
+   *   email: 'newuser@example.com',
+   *   roleId: 'role-uuid',
+   *   tenantId: 'tenant-uuid',
+   *   redirectUrl: 'https://myapp.com/accept-invite'
+   * });
+   * ```
+   */
+  async sendInvite(options) {
+    await this.client.post("/auth/invite", {
+      email: options.email,
+      role_Id: options.roleId,
+      tenant_Id: options.tenantId,
+      link: options.redirectUrl
+    });
+  }
+  /**
+   * Verify an invitation token
+   * 
+   * @example
+   * ```typescript
+   * const params = new URLSearchParams(window.location.search);
+   * const token = params.get('token');
+   * 
+   * const result = await baasix.auth.verifyInvite(token);
+   * if (result.valid) {
+   *   // Show registration form with pre-filled email
+   * }
+   * ```
+   */
+  async verifyInvite(token, redirectUrl) {
+    const response = await this.client.get(
+      "/auth/verify-invite",
+      {
+        params: {
+          token,
+          link: redirectUrl
+        },
+        skipAuth: true
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Accept an invitation (for existing users)
+   * 
+   * @example
+   * ```typescript
+   * await baasix.auth.acceptInvite(token);
+   * ```
+   */
+  async acceptInvite(token) {
+    const response = await this.client.post(
+      "/auth/accept-invite",
+      { token }
+    );
+    await this.storeTokens(response);
+    this.emitAuthStateChange("SIGNED_IN", response.user);
+    return response;
+  }
+  /**
+   * Register with an invitation token
+   * 
+   * @example
+   * ```typescript
+   * const { user, token } = await baasix.auth.registerWithInvite({
+   *   email: 'user@example.com',
+   *   password: 'password',
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   inviteToken: 'invite-token'
+   * });
+   * ```
+   */
+  async registerWithInvite(data) {
+    const response = await this.client.post(
+      "/auth/register",
+      {
+        ...data,
+        inviteToken: data.inviteToken
+      },
+      { skipAuth: true }
+    );
+    await this.storeTokens(response);
+    this.emitAuthStateChange("SIGNED_IN", response.user);
+    return response;
+  }
+};
+
+// src/modules/items.ts
+var QueryBuilder = class {
+  collection;
+  client;
+  queryParams = {};
+  constructor(collection, client) {
+    this.collection = collection;
+    this.client = client;
+  }
+  /**
+   * Select specific fields to return
+   *
+   * @example
+   * ```typescript
+   * items.select(['id', 'name', 'author.*'])
+   * items.select('*', 'category.name')
+   * ```
+   */
+  select(...fields) {
+    const flatFields = fields.length === 1 && Array.isArray(fields[0]) ? fields[0] : fields;
+    this.queryParams.fields = flatFields;
+    return this;
+  }
+  /**
+   * Alias for select()
+   */
+  fields(...fields) {
+    return this.select(...fields);
+  }
+  /**
+   * Add filter conditions
+   *
+   * @example
+   * ```typescript
+   * // Simple equality
+   * items.filter({ status: { eq: 'active' } })
+   *
+   * // Multiple conditions
+   * items.filter({
+   *   AND: [
+   *     { status: { eq: 'active' } },
+   *     { price: { gte: 100 } }
+   *   ]
+   * })
+   *
+   * // Relation filtering
+   * items.filter({ 'author.name': { like: 'John' } })
+   * ```
+   */
+  filter(filter) {
+    this.queryParams.filter = filter;
+    return this;
+  }
+  /**
+   * Alias for filter()
+   */
+  where(filter) {
+    return this.filter(filter);
+  }
+  /**
+   * Sort results
+   *
+   * @example
+   * ```typescript
+   * // Object notation
+   * items.sort({ createdAt: 'desc', name: 'asc' })
+   *
+   * // Array notation with prefix
+   * items.sort(['-createdAt', 'name'])
+   *
+   * // String shorthand
+   * items.sort('createdAt:desc')
+   * ```
+   */
+  sort(sort) {
+    this.queryParams.sort = sort;
+    return this;
+  }
+  /**
+   * Alias for sort()
+   */
+  orderBy(sort) {
+    return this.sort(sort);
+  }
+  /**
+   * Limit number of results
+   *
+   * @example
+   * ```typescript
+   * items.limit(20)
+   * items.limit(-1) // All results
+   * ```
+   */
+  limit(limit) {
+    this.queryParams.limit = limit;
+    return this;
+  }
+  /**
+   * Set page number (1-indexed)
+   *
+   * @example
+   * ```typescript
+   * items.page(2).limit(20)
+   * ```
+   */
+  page(page) {
+    this.queryParams.page = page;
+    return this;
+  }
+  /**
+   * Skip a number of results
+   *
+   * @example
+   * ```typescript
+   * items.offset(20)
+   * ```
+   */
+  offset(offset) {
+    this.queryParams.offset = offset;
+    return this;
+  }
+  /**
+   * Full-text search
+   *
+   * @example
+   * ```typescript
+   * items.search('keyword', ['title', 'description'])
+   * ```
+   */
+  search(query, fields) {
+    this.queryParams.search = query;
+    if (fields) {
+      this.queryParams.searchFields = fields;
+    }
+    return this;
+  }
+  /**
+   * Include soft-deleted items
+   *
+   * @example
+   * ```typescript
+   * items.withDeleted()
+   * ```
+   */
+  withDeleted() {
+    this.queryParams.paranoid = false;
+    return this;
+  }
+  /**
+   * Filter related items in O2M/M2M relations
+   *
+   * @example
+   * ```typescript
+   * // Only show approved comments
+   * items.relFilter({
+   *   comments: { approved: { eq: true } }
+   * })
+   * ```
+   */
+  relFilter(conditions) {
+    this.queryParams.relConditions = conditions;
+    return this;
+  }
+  /**
+   * Get the built query parameters
+   */
+  getQuery() {
+    return { ...this.queryParams };
+  }
+  /**
+   * Execute the query and return results
+   *
+   * @example
+   * ```typescript
+   * const { data, totalCount } = await items
+   *   .filter({ status: { eq: 'active' } })
+   *   .sort({ createdAt: 'desc' })
+   *   .limit(10)
+   *   .get();
+   * ```
+   */
+  async get() {
+    return this.client.get(`/items/${this.collection}`, {
+      params: this.buildParams()
+    });
+  }
+  /**
+   * Execute the query and return the first result
+   *
+   * @example
+   * ```typescript
+   * const item = await items
+   *   .filter({ slug: { eq: 'my-post' } })
+   *   .first();
+   * ```
+   */
+  async first() {
+    const result = await this.limit(1).get();
+    return result.data[0] || null;
+  }
+  /**
+   * Count matching items
+   *
+   * @example
+   * ```typescript
+   * const count = await items.filter({ status: { eq: 'active' } }).count();
+   * ```
+   */
+  async count() {
+    const result = await this.client.get(
+      `/items/${this.collection}`,
+      {
+        params: {
+          ...this.buildParams(),
+          limit: 0
+        }
+      }
+    );
+    return result.totalCount || 0;
+  }
+  /**
+   * Build query parameters for the request
+   */
+  buildParams() {
+    const params = {};
+    if (this.queryParams.fields) {
+      params.fields = this.queryParams.fields;
+    }
+    if (this.queryParams.filter) {
+      params.filter = this.queryParams.filter;
+    }
+    if (this.queryParams.sort) {
+      params.sort = this.queryParams.sort;
+    }
+    if (this.queryParams.limit !== void 0) {
+      params.limit = this.queryParams.limit;
+    }
+    if (this.queryParams.page !== void 0) {
+      params.page = this.queryParams.page;
+    }
+    if (this.queryParams.offset !== void 0) {
+      params.offset = this.queryParams.offset;
+    }
+    if (this.queryParams.search) {
+      params.search = this.queryParams.search;
+    }
+    if (this.queryParams.searchFields) {
+      params.searchFields = this.queryParams.searchFields;
+    }
+    if (this.queryParams.paranoid !== void 0) {
+      params.paranoid = this.queryParams.paranoid;
+    }
+    if (this.queryParams.relConditions) {
+      params.relConditions = this.queryParams.relConditions;
+    }
+    if (this.queryParams.aggregate) {
+      params.aggregate = this.queryParams.aggregate;
+    }
+    if (this.queryParams.groupBy) {
+      params.groupBy = this.queryParams.groupBy;
+    }
+    return params;
+  }
+};
+var ItemsModule = class {
+  collection;
+  client;
+  constructor(collection, config) {
+    this.collection = collection;
+    this.client = config.client;
+  }
+  /**
+   * Create a query builder for fluent query construction
+   *
+   * @example
+   * ```typescript
+   * const results = await baasix.items('posts')
+   *   .query()
+   *   .select('*', 'author.*')
+   *   .filter({ status: { eq: 'published' } })
+   *   .sort({ createdAt: 'desc' })
+   *   .limit(10)
+   *   .get();
+   * ```
+   */
+  query() {
+    return new QueryBuilder(this.collection, this.client);
+  }
+  /**
+   * Find items with optional query parameters
+   *
+   * @example
+   * ```typescript
+   * // Simple query
+   * const { data } = await items.find();
+   *
+   * // With parameters
+   * const { data, totalCount } = await items.find({
+   *   filter: { status: { eq: 'active' } },
+   *   sort: { createdAt: 'desc' },
+   *   limit: 20,
+   *   page: 1,
+   *   fields: ['id', 'name', 'price']
+   * });
+   * ```
+   */
+  async find(params) {
+    return this.client.get(`/items/${this.collection}`, {
+      params
+    });
+  }
+  /**
+   * Alias for find()
+   */
+  async findMany(params) {
+    return this.find(params);
+  }
+  /**
+   * Find a single item by ID
+   *
+   * @example
+   * ```typescript
+   * const product = await items.findOne('product-uuid');
+   *
+   * // With specific fields
+   * const product = await items.findOne('product-uuid', {
+   *   fields: ['id', 'name', 'category.*']
+   * });
+   * ```
+   */
+  async findOne(id, params) {
+    const response = await this.client.get(
+      `/items/${this.collection}/${id}`,
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Alias for findOne()
+   */
+  async get(id, params) {
+    return this.findOne(id, params);
+  }
+  /**
+   * Create a new item
+   *
+   * @example
+   * ```typescript
+   * const id = await items.create({
+   *   name: 'New Product',
+   *   price: 29.99,
+   *   status: 'draft'
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      `/items/${this.collection}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Alias for create()
+   */
+  async insert(data) {
+    return this.create(data);
+  }
+  /**
+   * Create multiple items at once
+   *
+   * @example
+   * ```typescript
+   * const ids = await items.createMany([
+   *   { name: 'Product 1', price: 10 },
+   *   { name: 'Product 2', price: 20 }
+   * ]);
+   * ```
+   */
+  async createMany(data) {
+    const response = await this.client.post(
+      `/items/${this.collection}/bulk`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Alias for createMany()
+   */
+  async insertMany(data) {
+    return this.createMany(data);
+  }
+  /**
+   * Update an existing item
+   *
+   * @example
+   * ```typescript
+   * await items.update('product-uuid', {
+   *   price: 24.99,
+   *   status: 'published'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/items/${this.collection}/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update multiple items at once
+   *
+   * @example
+   * ```typescript
+   * // Update by IDs with same data
+   * await items.updateMany(['id1', 'id2'], { status: 'archived' });
+   * ```
+   */
+  async updateMany(ids, data) {
+    const updates = ids.map((id) => ({ id, data }));
+    const response = await this.client.patch(
+      `/items/${this.collection}/bulk`,
+      updates
+    );
+    return response.data;
+  }
+  /**
+   * Upsert an item (create if not exists, update if exists)
+   *
+   * @example
+   * ```typescript
+   * const id = await items.upsert(
+   *   { sku: 'WIDGET-001' },
+   *   { name: 'Widget', price: 29.99, sku: 'WIDGET-001' }
+   * );
+   * ```
+   */
+  async upsert(filter, data) {
+    const existing = await this.find({ filter, limit: 1 });
+    if (existing.data.length > 0) {
+      return this.update(existing.data[0].id, data);
+    }
+    return this.create(data);
+  }
+  /**
+   * Delete an item by ID
+   *
+   * @example
+   * ```typescript
+   * await items.delete('product-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/items/${this.collection}/${id}`);
+  }
+  /**
+   * Delete multiple items
+   *
+   * @example
+   * ```typescript
+   * await items.deleteMany(['id1', 'id2', 'id3']);
+   * ```
+   */
+  async deleteMany(ids) {
+    await this.client.delete(`/items/${this.collection}/bulk`, {
+      body: JSON.stringify(ids)
+    });
+  }
+  /**
+   * Soft delete an item (if paranoid mode is enabled)
+   *
+   * @example
+   * ```typescript
+   * await items.softDelete('product-uuid');
+   * ```
+   */
+  async softDelete(id) {
+    await this.update(id, { deletedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  /**
+   * Restore a soft-deleted item
+   *
+   * @example
+   * ```typescript
+   * await items.restore('product-uuid');
+   * ```
+   */
+  async restore(id) {
+    await this.update(id, { deletedAt: null });
+  }
+  /**
+   * Aggregate data with grouping
+   *
+   * @example
+   * ```typescript
+   * const results = await items.aggregate({
+   *   aggregate: {
+   *     total: { function: 'sum', field: 'amount' },
+   *     count: { function: 'count', field: 'id' },
+   *     avgPrice: { function: 'avg', field: 'price' }
+   *   },
+   *   groupBy: ['category', 'status'],
+   *   filter: { createdAt: { gte: '$NOW-DAYS_30' } }
+   * });
+   * ```
+   */
+  async aggregate(params) {
+    const response = await this.client.get(
+      `/items/${this.collection}`,
+      { params }
+    );
+    return response.data;
+  }
+  // ===================
+  // Import Operations
+  // ===================
+  /**
+   * Import items from a CSV file
+   *
+   * @example
+   * ```typescript
+   * // Browser
+   * const fileInput = document.querySelector('input[type="file"]');
+   * const file = fileInput.files[0];
+   * 
+   * const result = await baasix.items('products').importCSV(file);
+   * 
+   * console.log(`Imported ${result.imported} items`);
+   * ```
+   */
+  async importCSV(file) {
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("csvFile", file);
+    } else {
+      formData.append("csvFile", file);
+    }
+    const response = await this.client.post(
+      `/items/${this.collection}/import-csv`,
+      formData
+    );
+    return response.results;
+  }
+  /**
+   * Import items from a JSON file
+   *
+   * @example
+   * ```typescript
+   * const file = fileInput.files[0]; // JSON file
+   * const result = await baasix.items('products').importJSON(file);
+   * 
+   * console.log(`Imported ${result.imported} items`);
+   * ```
+   */
+  async importJSON(file) {
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("jsonFile", file);
+    } else {
+      formData.append("jsonFile", file);
+    }
+    const response = await this.client.post(
+      `/items/${this.collection}/import-json`,
+      formData
+    );
+    return response.results;
+  }
+  /**
+   * Import items from an array of objects
+   *
+   * @example
+   * ```typescript
+   * const data = [
+   *   { name: 'Product 1', price: 29.99 },
+   *   { name: 'Product 2', price: 39.99 }
+   * ];
+   * 
+   * const result = await baasix.items('products').importData(data);
+   * ```
+   */
+  async importData(data) {
+    const response = await this.client.post(
+      `/items/${this.collection}/bulk`,
+      data
+    );
+    return response;
+  }
+  // ===================
+  // Sort Operations
+  // ===================
+  /**
+   * Sort/reorder items (move item before or after another)
+   *
+   * @example
+   * ```typescript
+   * // Move item1 before item2
+   * await baasix.items('products').sortItem('item1-uuid', 'item2-uuid');
+   * 
+   * // Move item1 after item2
+   * await baasix.items('products').sortItem('item1-uuid', 'item2-uuid', 'after');
+   * ```
+   */
+  async sortItem(itemId, targetItemId, mode = "before") {
+    await this.client.post(`/utils/sort/${this.collection}`, {
+      item: itemId,
+      to: targetItemId,
+      mode
+    });
+  }
+  /**
+   * Reorder multiple items
+   *
+   * @example
+   * ```typescript
+   * // Set explicit order
+   * await baasix.items('products').reorder([
+   *   'item3-uuid',
+   *   'item1-uuid',
+   *   'item2-uuid'
+   * ]);
+   * ```
+   */
+  async reorder(orderedIds) {
+    for (let i = 1; i < orderedIds.length; i++) {
+      await this.client.post(`/utils/sort/${this.collection}`, {
+        item: orderedIds[i],
+        to: orderedIds[i - 1],
+        mode: "after"
+      });
+    }
+  }
+};
+
+// src/modules/files.ts
+var FilesModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Upload a file
+   *
+   * @example
+   * ```typescript
+   * // Browser File API
+   * const metadata = await baasix.files.upload(fileInput.files[0], {
+   *   title: 'Product Image',
+   *   folder: 'products',
+   *   isPublic: true,
+   *   onProgress: (progress) => console.log(`${progress}% uploaded`)
+   * });
+   *
+   * // React Native with expo-image-picker
+   * const metadata = await baasix.files.upload({
+   *   uri: result.uri,
+   *   name: 'photo.jpg',
+   *   type: 'image/jpeg'
+   * });
+   * ```
+   */
+  async upload(file, options) {
+    const formData = new FormData();
+    if (file instanceof File || file instanceof Blob) {
+      formData.append("file", file);
+    } else {
+      formData.append("file", file);
+    }
+    if (options?.title) {
+      formData.append("title", options.title);
+    }
+    if (options?.description) {
+      formData.append("description", options.description);
+    }
+    if (options?.folder) {
+      formData.append("folder", options.folder);
+    }
+    if (options?.storage) {
+      formData.append("storage", options.storage);
+    }
+    if (options?.isPublic !== void 0) {
+      formData.append("isPublic", String(options.isPublic));
+    }
+    if (options?.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    const response = await this.client.upload(
+      "/files",
+      formData,
+      {
+        onProgress: options?.onProgress,
+        timeout: options?.timeout
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Upload multiple files
+   *
+   * @example
+   * ```typescript
+   * const files = await baasix.files.uploadMany(fileInput.files, {
+   *   folder: 'gallery',
+   *   isPublic: true
+   * });
+   * ```
+   */
+  async uploadMany(files, options) {
+    const results = [];
+    const fileArray = files instanceof FileList ? Array.from(files) : files;
+    for (const file of fileArray) {
+      const metadata = await this.upload(file, options);
+      results.push(metadata);
+    }
+    return results;
+  }
+  /**
+   * List files with optional filtering
+   *
+   * @example
+   * ```typescript
+   * const { data, totalCount } = await baasix.files.find({
+   *   filter: { mimeType: { startsWith: 'image/' } },
+   *   limit: 20
+   * });
+   * ```
+   */
+  async find(params) {
+    return this.client.get("/files", {
+      params
+    });
+  }
+  /**
+   * Get file metadata by ID
+   *
+   * @example
+   * ```typescript
+   * const file = await baasix.files.findOne('file-uuid');
+   * console.log(file.filename, file.size);
+   * ```
+   */
+  async findOne(id) {
+    const response = await this.client.get(`/files/${id}`);
+    return response.data;
+  }
+  /**
+   * Update file metadata
+   *
+   * @example
+   * ```typescript
+   * await baasix.files.update('file-uuid', {
+   *   title: 'Updated Title',
+   *   description: 'New description'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/files/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete a file
+   *
+   * @example
+   * ```typescript
+   * await baasix.files.delete('file-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/files/${id}`);
+  }
+  /**
+   * Delete multiple files
+   *
+   * @example
+   * ```typescript
+   * await baasix.files.deleteMany(['id1', 'id2', 'id3']);
+   * ```
+   */
+  async deleteMany(ids) {
+    await Promise.all(ids.map((id) => this.delete(id)));
+  }
+  /**
+   * Get the URL for an asset with optional transformations
+   *
+   * @example
+   * ```typescript
+   * // Original file
+   * const url = baasix.files.getAssetUrl('file-uuid');
+   *
+   * // Resized thumbnail
+   * const thumbUrl = baasix.files.getAssetUrl('file-uuid', {
+   *   width: 200,
+   *   height: 200,
+   *   fit: 'cover',
+   *   quality: 80
+   * });
+   *
+   * // Convert to WebP
+   * const webpUrl = baasix.files.getAssetUrl('file-uuid', {
+   *   format: 'webp',
+   *   quality: 85
+   * });
+   * ```
+   */
+  getAssetUrl(id, options) {
+    const baseUrl = this.client.getBaseUrl();
+    const url = new URL(`/assets/${id}`, baseUrl);
+    if (options) {
+      if (options.width) {
+        url.searchParams.set("width", String(options.width));
+      }
+      if (options.height) {
+        url.searchParams.set("height", String(options.height));
+      }
+      if (options.fit) {
+        url.searchParams.set("fit", options.fit);
+      }
+      if (options.quality) {
+        url.searchParams.set("quality", String(options.quality));
+      }
+      if (options.format) {
+        url.searchParams.set("format", options.format);
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Download a file as a Blob
+   *
+   * @example
+   * ```typescript
+   * const blob = await baasix.files.download('file-uuid');
+   *
+   * // Create download link
+   * const url = URL.createObjectURL(blob);
+   * const a = document.createElement('a');
+   * a.href = url;
+   * a.download = 'filename.pdf';
+   * a.click();
+   * ```
+   */
+  async download(id, options) {
+    const url = this.getAssetUrl(id, options);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download file: ${response.statusText}`);
+    }
+    return response.blob();
+  }
+  /**
+   * Get file as base64 string (useful for React Native)
+   *
+   * @example
+   * ```typescript
+   * const base64 = await baasix.files.toBase64('file-uuid');
+   * // Use in Image component: <Image source={{ uri: `data:image/jpeg;base64,${base64}` }} />
+   * ```
+   */
+  async toBase64(id, options) {
+    const blob = await this.download(id, options);
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const result = reader.result;
+        const base64 = result.split(",")[1];
+        resolve(base64);
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  /**
+   * Import file from URL
+   *
+   * @example
+   * ```typescript
+   * const file = await baasix.files.importFromUrl(
+   *   'https://example.com/image.jpg',
+   *   { title: 'Imported Image' }
+   * );
+   * ```
+   */
+  async importFromUrl(url, options) {
+    const response = await this.client.post(
+      "/files/import",
+      {
+        url,
+        ...options
+      }
+    );
+    return response.data;
+  }
+};
+
+// src/utils/sort.ts
+function normalizeSort(sort) {
+  if (!sort) return void 0;
+  if (typeof sort === "string") {
+    return sort;
+  }
+  if (Array.isArray(sort)) {
+    if (sort.length === 0) return void 0;
+    if (typeof sort[0] === "object" && "column" in sort[0]) {
+      return sort.map((s) => `${s.column}:${s.order.toLowerCase()}`).join(",");
+    }
+    return sort.map((s) => {
+      if (s.startsWith("-")) {
+        return `${s.substring(1)}:desc`;
+      }
+      if (s.includes(":")) {
+        return s;
+      }
+      return `${s}:asc`;
+    }).join(",");
+  }
+  if (typeof sort === "object") {
+    const entries = Object.entries(sort);
+    if (entries.length === 0) return void 0;
+    return entries.map(([field, direction]) => `${field}:${direction.toLowerCase()}`).join(",");
+  }
+  return void 0;
+}
+
+// src/modules/schemas.ts
+var SchemasModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * List all schemas
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.schemas.find();
+   * console.log(data.map(s => s.collectionName));
+   * 
+   * // With pagination
+   * const { data } = await baasix.schemas.find({ page: 1, limit: 50 });
+   * ```
+   */
+  async find(params) {
+    const normalizedParams = params ? {
+      ...params,
+      sort: normalizeSort(params.sort)
+    } : void 0;
+    return this.client.get("/schemas", { params: normalizedParams });
+  }
+  /**
+   * Get schema for a specific collection
+   *
+   * @example
+   * ```typescript
+   * const schema = await baasix.schemas.findOne('products');
+   * console.log(schema.fields);
+   * ```
+   */
+  async findOne(collection) {
+    const response = await this.client.get(
+      `/schemas/${collection}`
+    );
+    return response.data;
+  }
+  /**
+   * Create a new collection/schema
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.create({
+   *   collectionName: 'orders',
+   *   schema: {
+   *     name: 'Order',
+   *     timestamps: true,
+   *     paranoid: true,
+   *     fields: {
+   *       id: {
+   *         type: 'UUID',
+   *         primaryKey: true,
+   *         defaultValue: { type: 'UUIDV4' }
+   *       },
+   *       orderNumber: {
+   *         type: 'String',
+   *         allowNull: false,
+   *         unique: true
+   *       },
+   *       total: {
+   *         type: 'Decimal',
+   *         values: { precision: 10, scale: 2 },
+   *         allowNull: false,
+   *         defaultValue: 0
+   *       },
+   *       status: {
+   *         type: 'String',
+   *         allowNull: false,
+   *         defaultValue: 'pending'
+   *       },
+   *       items: {
+   *         type: 'JSONB',
+   *         allowNull: true,
+   *         defaultValue: []
+   *       }
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/schemas",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update an existing schema
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.update('products', {
+   *   schema: {
+   *     name: 'Product',
+   *     timestamps: true,
+   *     fields: {
+   *       // Updated fields
+   *       description: { type: 'Text', allowNull: true }
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  async update(collection, data) {
+    const response = await this.client.patch(
+      `/schemas/${collection}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete a schema (drops the table)
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.delete('old_collection');
+   * ```
+   */
+  async delete(collection) {
+    await this.client.delete(`/schemas/${collection}`);
+  }
+  /**
+   * Create a relationship between collections
+   *
+   * @example
+   * ```typescript
+   * // Many-to-One (BelongsTo)
+   * await baasix.schemas.createRelationship('posts', {
+   *   type: 'M2O',
+   *   target: 'baasix_User',
+   *   name: 'author',
+   *   alias: 'posts'
+   * });
+   *
+   * // Many-to-Many
+   * await baasix.schemas.createRelationship('posts', {
+   *   type: 'M2M',
+   *   target: 'tags',
+   *   name: 'tags',
+   *   alias: 'posts'
+   * });
+   * ```
+   */
+  async createRelationship(collection, relationship) {
+    await this.client.post(
+      `/schemas/${collection}/relationships`,
+      relationship
+    );
+  }
+  /**
+   * Delete a relationship
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.deleteRelationship('posts', 'author');
+   * ```
+   */
+  async deleteRelationship(collection, relationshipName) {
+    await this.client.delete(
+      `/schemas/${collection}/relationships/${relationshipName}`
+    );
+  }
+  /**
+   * Update a relationship
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.updateRelationship('posts', 'author', {
+   *   alias: 'authoredPosts',
+   *   onDelete: 'CASCADE'
+   * });
+   * ```
+   */
+  async updateRelationship(collection, relationshipName, data) {
+    await this.client.patch(
+      `/schemas/${collection}/relationships/${relationshipName}`,
+      data
+    );
+  }
+  /**
+   * Create an index on a collection
+   *
+   * @example
+   * ```typescript
+   * // Unique index
+   * await baasix.schemas.createIndex('users', {
+   *   name: 'idx_users_email',
+   *   fields: ['email'],
+   *   unique: true
+   * });
+   *
+   * // Composite index
+   * await baasix.schemas.createIndex('orders', {
+   *   name: 'idx_orders_status_created',
+   *   fields: ['status', 'createdAt']
+   * });
+   * ```
+   */
+  async createIndex(collection, index) {
+    await this.client.post(`/schemas/${collection}/indexes`, index);
+  }
+  /**
+   * Delete an index
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.deleteIndex('users', 'idx_users_email');
+   * ```
+   */
+  async deleteIndex(collection, indexName) {
+    await this.client.delete(`/schemas/${collection}/indexes/${indexName}`);
+  }
+  /**
+   * Add a field to an existing schema
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.addField('products', 'rating', {
+   *   type: 'Decimal',
+   *   values: { precision: 3, scale: 2 },
+   *   allowNull: true,
+   *   defaultValue: 0
+   * });
+   * ```
+   */
+  async addField(collection, fieldName, fieldDefinition) {
+    const currentSchema = await this.findOne(collection);
+    const updatedFields = {
+      ...currentSchema.schema.fields,
+      [fieldName]: fieldDefinition
+    };
+    return this.update(collection, {
+      schema: {
+        ...currentSchema.schema,
+        fields: updatedFields
+      }
+    });
+  }
+  /**
+   * Remove a field from a schema
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.removeField('products', 'deprecated_field');
+   * ```
+   */
+  async removeField(collection, fieldName) {
+    const currentSchema = await this.findOne(collection);
+    const { [fieldName]: _, ...remainingFields } = currentSchema.schema.fields;
+    return this.update(collection, {
+      schema: {
+        ...currentSchema.schema,
+        fields: remainingFields
+      }
+    });
+  }
+  /**
+   * Export all schemas as JSON
+   *
+   * @example
+   * ```typescript
+   * const schemas = await baasix.schemas.export();
+   * // Save to file for backup
+   * ```
+   */
+  async export() {
+    const response = await this.client.get(
+      "/schemas/export"
+    );
+    return response.data;
+  }
+  /**
+   * Import schemas from JSON
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.import(savedSchemas);
+   * ```
+   */
+  async import(schemas) {
+    await this.client.post("/schemas/import", { schemas });
+  }
+};
+
+// src/modules/notifications.ts
+var NotificationsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * List notifications for the current user
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.notifications.find({
+   *   limit: 20,
+   *   filter: { seen: { eq: false } }
+   * });
+   * ```
+   */
+  async find(params) {
+    return this.client.get("/notifications", {
+      params
+    });
+  }
+  /**
+   * Get unread notification count
+   *
+   * @example
+   * ```typescript
+   * const count = await baasix.notifications.getUnreadCount();
+   * ```
+   */
+  async getUnreadCount() {
+    const response = await this.client.get(
+      "/notifications/unread/count"
+    );
+    return response.count;
+  }
+  /**
+   * 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();
+   * ```
+   */
+  async markAsSeen(notificationIds) {
+    const response = await this.client.post(
+      "/notifications/mark-seen",
+      { notificationIds }
+    );
+    return { count: response.count };
+  }
+  /**
+   * Delete notifications for the current user
+   *
+   * @example
+   * ```typescript
+   * // Delete specific notifications
+   * await baasix.notifications.delete(['id1', 'id2']);
+   * 
+   * // Delete all notifications
+   * await baasix.notifications.delete();
+   * ```
+   */
+  async delete(notificationIds) {
+    const response = await this.client.delete(
+      "/notifications",
+      { params: notificationIds ? { notificationIds } : void 0 }
+    );
+    return { count: response.count };
+  }
+  /**
+   * 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']
+   * });
+   * ```
+   */
+  async send(data) {
+    const response = await this.client.post(
+      "/notifications/send",
+      data
+    );
+    return { notificationIds: response.notificationIds };
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async cleanup(days = 30) {
+    const response = await this.client.post(
+      "/notifications/cleanup",
+      { days }
+    );
+    return { count: response.count };
+  }
+};
+
+// src/modules/permissions.ts
+var PermissionsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * List all permissions
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.permissions.find();
+   * ```
+   */
+  async find(params) {
+    return this.client.get("/permissions", {
+      params
+    });
+  }
+  /**
+   * Get a permission by ID
+   */
+  async findOne(id) {
+    const response = await this.client.get(
+      `/permissions/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get permissions for a specific role
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.permissions.findByRole('role-uuid');
+   * ```
+   */
+  async findByRole(roleId) {
+    return this.client.get("/permissions", {
+      params: {
+        filter: { role_Id: { eq: roleId } },
+        limit: -1
+      }
+    });
+  }
+  /**
+   * Get permissions for a specific collection
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.permissions.findByCollection('products');
+   * ```
+   */
+  async findByCollection(collection) {
+    return this.client.get("/permissions", {
+      params: {
+        filter: { collection: { eq: collection } },
+        limit: -1
+      }
+    });
+  }
+  /**
+   * 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' }
+   *   }
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/permissions",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update a permission
+   *
+   * @example
+   * ```typescript
+   * await baasix.permissions.update('permission-uuid', {
+   *   fields: ['*'],
+   *   conditions: null
+   * });
+   * ```
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/permissions/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete a permission
+   *
+   * @example
+   * ```typescript
+   * await baasix.permissions.delete('permission-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/permissions/${id}`);
+  }
+  /**
+   * List all roles
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.permissions.getRoles();
+   * ```
+   */
+  async getRoles() {
+    return this.client.get("/items/baasix_Role", {
+      params: { limit: -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
+   * });
+   * ```
+   */
+  async createCrudPermissions(roleId, collection, config) {
+    const permissions = [];
+    const actions = ["create", "read", "update", "delete"];
+    for (const action of actions) {
+      const actionConfig = config[action];
+      if (actionConfig === false) continue;
+      const permission = await this.create({
+        role_Id: roleId,
+        collection,
+        action,
+        fields: actionConfig?.fields || ["*"],
+        conditions: actionConfig?.conditions
+      });
+      permissions.push(permission);
+    }
+    return permissions;
+  }
+  /**
+   * Reload permissions cache (admin only)
+   *
+   * @example
+   * ```typescript
+   * await baasix.permissions.reloadCache();
+   * ```
+   */
+  async reloadCache() {
+    await this.client.post("/permissions/reload");
+  }
+};
+
+// src/modules/settings.ts
+var SettingsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Get all settings
+   *
+   * @example
+   * ```typescript
+   * const settings = await baasix.settings.get();
+   * console.log(settings.appName);
+   * ```
+   */
+  async get() {
+    const response = await this.client.get("/settings");
+    return response.data;
+  }
+  /**
+   * Get a specific setting by key
+   *
+   * @example
+   * ```typescript
+   * const appName = await baasix.settings.getKey('appName');
+   * ```
+   */
+  async getKey(key) {
+    const settings = await this.get();
+    return settings[key] ?? null;
+  }
+  /**
+   * Update settings
+   *
+   * @example
+   * ```typescript
+   * await baasix.settings.update({
+   *   appName: 'Updated App Name',
+   *   logo: 'file-uuid',
+   *   customConfig: {
+   *     feature1: true,
+   *     feature2: false
+   *   }
+   * });
+   * ```
+   */
+  async update(settings) {
+    const response = await this.client.patch(
+      "/settings",
+      settings
+    );
+    return response.data;
+  }
+  /**
+   * Set a specific setting
+   *
+   * @example
+   * ```typescript
+   * await baasix.settings.set('appName', 'My New App Name');
+   * ```
+   */
+  async set(key, value) {
+    return this.update({ [key]: value });
+  }
+};
+
+// src/modules/reports.ts
+var ReportsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * 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'
+   *   }
+   * });
+   * ```
+   */
+  async generate(collection, config) {
+    const response = await this.client.post(
+      `/reports/${collection}`,
+      config
+    );
+    return response;
+  }
+  /**
+   * 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']
+   * });
+   * ```
+   */
+  async query(collection, params) {
+    const response = await this.client.get(
+      `/reports/${collection}`,
+      { params }
+    );
+    return response;
+  }
+  /**
+   * 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' }
+   *       }
+   *     }
+   *   }
+   * ]);
+   * ```
+   */
+  async getStats(stats) {
+    const response = await this.client.post(`/reports/stats`, {
+      stats
+    });
+    return response;
+  }
+  /**
+   * 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' } }
+   * });
+   * ```
+   */
+  async aggregate(collection, options) {
+    const response = await this.client.get(
+      `/items/${collection}`,
+      {
+        params: {
+          aggregate: options.aggregate,
+          groupBy: options.groupBy,
+          filter: options.filter,
+          limit: -1
+        }
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Count items matching a filter
+   *
+   * @example
+   * ```typescript
+   * const activeUsers = await baasix.reports.count('users', {
+   *   status: { eq: 'active' }
+   * });
+   * ```
+   */
+  async count(collection, filter) {
+    const response = await this.client.get(
+      `/items/${collection}`,
+      {
+        params: {
+          filter,
+          limit: 0
+        }
+      }
+    );
+    return response.totalCount || 0;
+  }
+  /**
+   * Get distinct values for a field
+   *
+   * @example
+   * ```typescript
+   * const categories = await baasix.reports.distinct('products', 'category');
+   * ```
+   */
+  async distinct(collection, field, filter) {
+    const response = await this.client.get(
+      `/items/${collection}`,
+      {
+        params: {
+          filter,
+          fields: [field],
+          groupBy: [field],
+          limit: -1
+        }
+      }
+    );
+    return response.data.map((item) => item[field]);
+  }
+};
+
+// src/modules/workflows.ts
+var WorkflowsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * List all workflows
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.workflows.find();
+   * ```
+   */
+  async find(params) {
+    return this.client.get("/workflows", {
+      params
+    });
+  }
+  /**
+   * Get a workflow by ID
+   *
+   * @example
+   * ```typescript
+   * const workflow = await baasix.workflows.findOne('workflow-uuid');
+   * ```
+   */
+  async findOne(id) {
+    const response = await this.client.get(
+      `/workflows/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/workflows",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update a workflow
+   *
+   * @example
+   * ```typescript
+   * await baasix.workflows.update('workflow-uuid', {
+   *   name: 'Updated Workflow Name',
+   *   isActive: false
+   * });
+   * ```
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/workflows/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete a workflow
+   *
+   * @example
+   * ```typescript
+   * await baasix.workflows.delete('workflow-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/workflows/${id}`);
+  }
+  /**
+   * Execute a workflow manually
+   *
+   * @example
+   * ```typescript
+   * const result = await baasix.workflows.execute('workflow-uuid', {
+   *   // Trigger data
+   *   customerId: 'customer-123',
+   *   action: 'sendEmail'
+   * });
+   * ```
+   */
+  async execute(id, triggerData) {
+    const response = await this.client.post(
+      `/workflows/${id}/execute`,
+      { triggerData }
+    );
+    return response.data;
+  }
+  /**
+   * Test a workflow without persisting execution
+   *
+   * @example
+   * ```typescript
+   * const result = await baasix.workflows.test('workflow-uuid', {
+   *   testData: { value: 123 }
+   * });
+   * ```
+   */
+  async test(id, triggerData) {
+    const response = await this.client.post(
+      `/workflows/${id}/test`,
+      { triggerData }
+    );
+    return response.data;
+  }
+  /**
+   * Get workflow execution history
+   *
+   * @example
+   * ```typescript
+   * const { data } = await baasix.workflows.getExecutions('workflow-uuid', {
+   *   limit: 50
+   * });
+   * ```
+   */
+  async getExecutions(id, params) {
+    return this.client.get(
+      `/workflows/${id}/executions`,
+      { params }
+    );
+  }
+  /**
+   * Get a specific execution
+   *
+   * @example
+   * ```typescript
+   * const execution = await baasix.workflows.getExecution(
+   *   'workflow-uuid',
+   *   'execution-uuid'
+   * );
+   * ```
+   */
+  async getExecution(workflowId, executionId) {
+    const response = await this.client.get(
+      `/workflows/${workflowId}/executions/${executionId}`
+    );
+    return response.data;
+  }
+  /**
+   * Cancel a running execution
+   *
+   * @example
+   * ```typescript
+   * await baasix.workflows.cancelExecution('workflow-uuid', 'execution-uuid');
+   * ```
+   */
+  async cancelExecution(workflowId, executionId) {
+    await this.client.post(
+      `/workflows/${workflowId}/executions/${executionId}/cancel`
+    );
+  }
+  /**
+   * Enable a workflow
+   *
+   * @example
+   * ```typescript
+   * await baasix.workflows.enable('workflow-uuid');
+   * ```
+   */
+  async enable(id) {
+    return this.update(id, { isActive: true });
+  }
+  /**
+   * Disable a workflow
+   *
+   * @example
+   * ```typescript
+   * await baasix.workflows.disable('workflow-uuid');
+   * ```
+   */
+  async disable(id) {
+    return this.update(id, { isActive: false });
+  }
+  /**
+   * Duplicate a workflow
+   *
+   * @example
+   * ```typescript
+   * const newWorkflow = await baasix.workflows.duplicate('workflow-uuid', {
+   *   name: 'Copy of My Workflow'
+   * });
+   * ```
+   */
+  async duplicate(id, overrides) {
+    const original = await this.findOne(id);
+    const { id: _, createdAt, updatedAt, ...workflowData } = original;
+    return this.create({
+      ...workflowData,
+      name: `Copy of ${workflowData.name}`,
+      ...overrides
+    });
+  }
+};
+
+// src/modules/realtime.ts
+var RealtimeModule = class {
+  client;
+  storage;
+  socket = null;
+  socketClient = null;
+  socketUrl;
+  socketPath;
+  subscriptions = /* @__PURE__ */ new Map();
+  workflowCallbacks = /* @__PURE__ */ new Map();
+  roomCallbacks = /* @__PURE__ */ new Map();
+  // room -> event -> callbacks
+  roomUserCallbacks = /* @__PURE__ */ new Map();
+  connectionCallbacks = /* @__PURE__ */ new Set();
+  reconnecting = false;
+  connectionPromise = null;
+  constructor(config) {
+    this.client = config.client;
+    this.storage = config.storage;
+    this.socketUrl = config.socketUrl || "";
+    this.socketPath = config.socketPath || "/realtime";
+  }
+  /**
+   * 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) {
+    this.socketClient = socketIO;
+  }
+  /**
+   * Set the WebSocket server URL
+   * By default, uses the same URL as the API
+   */
+  setSocketUrl(url) {
+    this.socketUrl = url;
+  }
+  /**
+   * Check if socket.io client is available
+   */
+  ensureSocketClient() {
+    if (!this.socketClient) {
+      throw new Error(
+        "Socket.io client not set. Please call baasix.realtime.setSocketClient(io) with socket.io-client."
+      );
+    }
+  }
+  /**
+   * Get the authentication token for socket connection
+   */
+  async getAuthToken() {
+    return await this.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+  }
+  /**
+   * Connect to the realtime server
+   * 
+   * @example
+   * ```typescript
+   * await baasix.realtime.connect();
+   * console.log('Connected to realtime server');
+   * ```
+   */
+  async connect() {
+    if (this.connectionPromise) {
+      return this.connectionPromise;
+    }
+    if (this.socket?.connected) {
+      return Promise.resolve();
+    }
+    this.ensureSocketClient();
+    this.connectionPromise = new Promise(async (resolve, reject) => {
+      try {
+        const token = await this.getAuthToken();
+        const baseUrl = this.socketUrl || this.client.getBaseUrl();
+        this.socket = this.socketClient(baseUrl, {
+          auth: { token: token || void 0 },
+          path: this.socketPath,
+          transports: ["websocket", "polling"],
+          reconnection: true,
+          reconnectionAttempts: 10,
+          reconnectionDelay: 1e3,
+          timeout: 2e4
+        });
+        this.socket.on("connect", () => {
+          console.log("[Baasix Realtime] Connected");
+          this.reconnecting = false;
+          this.notifyConnectionChange(true);
+          resolve();
+        });
+        this.socket.on("disconnect", (reason) => {
+          console.log("[Baasix Realtime] Disconnected:", reason);
+          this.notifyConnectionChange(false);
+        });
+        this.socket.on("connect_error", (error) => {
+          console.error("[Baasix Realtime] Connection error:", error.message);
+          if (!this.reconnecting) {
+            reject(error);
+          }
+        });
+        this.socket.on("reconnect", () => {
+          console.log("[Baasix Realtime] Reconnected");
+          this.reconnecting = false;
+          this.resubscribeAll();
+          this.notifyConnectionChange(true);
+        });
+        this.socket.on("reconnect_attempt", () => {
+          this.reconnecting = true;
+        });
+        this.socket.on("connected", (data) => {
+          console.log("[Baasix Realtime] Authenticated as user:", data.userId);
+        });
+        this.socket.on("workflow:execution:update", (data) => {
+          this.handleWorkflowUpdate(data);
+        });
+        this.socket.on("workflow:execution:complete", (data) => {
+          this.handleWorkflowUpdate({ ...data, status: "complete" });
+        });
+        this.socket.on("room:user:joined", (data) => {
+          const callbacks = this.roomUserCallbacks.get(data.room);
+          callbacks?.joined.forEach((cb) => {
+            try {
+              cb(data);
+            } catch (e) {
+              console.error("[Baasix Realtime] Error in room user joined callback:", e);
+            }
+          });
+        });
+        this.socket.on("room:user:left", (data) => {
+          const callbacks = this.roomUserCallbacks.get(data.room);
+          callbacks?.left.forEach((cb) => {
+            try {
+              cb(data);
+            } catch (e) {
+              console.error("[Baasix Realtime] Error in room user left callback:", e);
+            }
+          });
+        });
+        this.socket.connect();
+      } catch (error) {
+        this.connectionPromise = null;
+        reject(error);
+      }
+    });
+    try {
+      await this.connectionPromise;
+    } finally {
+      this.connectionPromise = null;
+    }
+  }
+  /**
+   * Disconnect from the realtime server
+   * 
+   * @example
+   * ```typescript
+   * baasix.realtime.disconnect();
+   * ```
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.subscriptions.clear();
+    this.workflowCallbacks.clear();
+    this.roomCallbacks.clear();
+    this.roomUserCallbacks.clear();
+  }
+  /**
+   * Check if connected to the realtime server
+   */
+  get isConnected() {
+    return this.socket?.connected ?? false;
+  }
+  /**
+   * Subscribe to connection state changes
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = baasix.realtime.onConnectionChange((connected) => {
+   *   console.log('Connection state:', connected ? 'online' : 'offline');
+   * });
+   * ```
+   */
+  onConnectionChange(callback) {
+    this.connectionCallbacks.add(callback);
+    return () => {
+      this.connectionCallbacks.delete(callback);
+    };
+  }
+  notifyConnectionChange(connected) {
+    this.connectionCallbacks.forEach((callback) => callback(connected));
+  }
+  /**
+   * 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(collection, callback) {
+    if (!this.socket?.connected) {
+      console.warn("[Baasix Realtime] Not connected. Call connect() first.");
+    }
+    const callbackId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    let subscription = this.subscriptions.get(collection);
+    if (!subscription) {
+      subscription = {
+        collection,
+        callbacks: /* @__PURE__ */ new Map()
+      };
+      this.subscriptions.set(collection, subscription);
+      this.subscribeOnServer(collection);
+      this.setupCollectionListeners(collection);
+    }
+    subscription.callbacks.set(callbackId, callback);
+    return () => {
+      const sub = this.subscriptions.get(collection);
+      if (sub) {
+        sub.callbacks.delete(callbackId);
+        if (sub.callbacks.size === 0) {
+          this.unsubscribeOnServer(collection);
+          this.removeCollectionListeners(collection);
+          this.subscriptions.delete(collection);
+        }
+      }
+    };
+  }
+  /**
+   * 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(collection, event, callback) {
+    return this.subscribe(collection, (payload) => {
+      if (payload.action === event) {
+        callback(payload.data);
+      }
+    });
+  }
+  /**
+   * 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) {
+    const unsubscribers = [];
+    this.subscriptions.forEach((_, collection) => {
+      const unsub = this.subscribe(collection, (payload) => {
+        callback(collection, payload);
+      });
+      unsubscribers.push(unsub);
+    });
+    return () => {
+      unsubscribers.forEach((unsub) => unsub());
+    };
+  }
+  subscribeOnServer(collection) {
+    if (this.socket?.connected) {
+      this.socket.emit("subscribe", { collection }, (response) => {
+        if (response.status === "error") {
+          console.error(`[Baasix Realtime] Failed to subscribe to ${collection}:`, response.message);
+        }
+      });
+    }
+  }
+  unsubscribeOnServer(collection) {
+    if (this.socket?.connected) {
+      this.socket.emit("unsubscribe", { collection });
+    }
+  }
+  setupCollectionListeners(collection) {
+    if (!this.socket) return;
+    const events = ["create", "update", "delete"];
+    events.forEach((event) => {
+      const eventName = `${collection}:${event}`;
+      this.socket.on(eventName, (payload) => {
+        this.handleCollectionEvent(collection, payload);
+      });
+    });
+  }
+  removeCollectionListeners(collection) {
+    if (!this.socket) return;
+    const events = ["create", "update", "delete"];
+    events.forEach((event) => {
+      const eventName = `${collection}:${event}`;
+      this.socket.off(eventName);
+    });
+  }
+  handleCollectionEvent(collection, payload) {
+    const subscription = this.subscriptions.get(collection);
+    if (subscription) {
+      subscription.callbacks.forEach((callback) => {
+        try {
+          callback(payload);
+        } catch (error) {
+          console.error(`[Baasix Realtime] Error in subscription callback:`, error);
+        }
+      });
+    }
+  }
+  resubscribeAll() {
+    this.subscriptions.forEach((_, collection) => {
+      this.subscribeOnServer(collection);
+      this.setupCollectionListeners(collection);
+    });
+  }
+  // ===================
+  // Workflow Realtime
+  // ===================
+  /**
+   * 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, callback) {
+    const id = String(executionId);
+    if (this.socket?.connected) {
+      this.socket.emit("workflow:execution:join", { executionId: id });
+    }
+    let callbacks = this.workflowCallbacks.get(id);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.workflowCallbacks.set(id, callbacks);
+    }
+    callbacks.add(callback);
+    return () => {
+      const cbs = this.workflowCallbacks.get(id);
+      if (cbs) {
+        cbs.delete(callback);
+        if (cbs.size === 0) {
+          this.workflowCallbacks.delete(id);
+        }
+      }
+    };
+  }
+  handleWorkflowUpdate(data) {
+    const id = String(data.executionId);
+    const callbacks = this.workflowCallbacks.get(id);
+    if (callbacks) {
+      callbacks.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`[Baasix Realtime] Error in workflow callback:`, error);
+        }
+      });
+    }
+  }
+  // ===================
+  // Custom Rooms API
+  // ===================
+  /**
+   * 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}`);
+   * });
+   * ```
+   */
+  async joinRoom(roomName) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("room:join", { room: roomName }, (response) => {
+        if (response.status === "success") {
+          this.setupRoomListeners(roomName);
+          resolve();
+        } else {
+          reject(new Error(response.message || "Failed to join room"));
+        }
+      });
+    });
+  }
+  /**
+   * Leave a custom room
+   * 
+   * @example
+   * ```typescript
+   * await baasix.realtime.leaveRoom('game:lobby');
+   * ```
+   */
+  async leaveRoom(roomName) {
+    if (!this.socket?.connected) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("room:leave", { room: roomName }, (response) => {
+        if (response.status === "success") {
+          this.cleanupRoomListeners(roomName);
+          resolve();
+        } else {
+          reject(new Error(response.message || "Failed to leave room"));
+        }
+      });
+    });
+  }
+  /**
+   * 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 });
+   * ```
+   */
+  async sendToRoom(roomName, event, payload) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit(
+        "room:message",
+        { room: roomName, event, payload },
+        (response) => {
+          if (response.status === "success") {
+            resolve();
+          } else {
+            reject(new Error(response.message || "Failed to send message"));
+          }
+        }
+      );
+    });
+  }
+  /**
+   * 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, event, callback) {
+    if (!this.roomCallbacks.has(roomName)) {
+      this.roomCallbacks.set(roomName, /* @__PURE__ */ new Map());
+    }
+    const roomEvents = this.roomCallbacks.get(roomName);
+    if (!roomEvents.has(event)) {
+      roomEvents.set(event, /* @__PURE__ */ new Set());
+    }
+    roomEvents.get(event).add(callback);
+    return () => {
+      const events = this.roomCallbacks.get(roomName);
+      if (events) {
+        const callbacks = events.get(event);
+        if (callbacks) {
+          callbacks.delete(callback);
+          if (callbacks.size === 0) {
+            events.delete(event);
+          }
+        }
+        if (events.size === 0) {
+          this.roomCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * 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, callback) {
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+    this.roomUserCallbacks.get(roomName).joined.add(callback);
+    return () => {
+      const callbacks = this.roomUserCallbacks.get(roomName);
+      if (callbacks) {
+        callbacks.joined.delete(callback);
+        if (callbacks.joined.size === 0 && callbacks.left.size === 0) {
+          this.roomUserCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * 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, callback) {
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+    this.roomUserCallbacks.get(roomName).left.add(callback);
+    return () => {
+      const callbacks = this.roomUserCallbacks.get(roomName);
+      if (callbacks) {
+        callbacks.left.delete(callback);
+        if (callbacks.joined.size === 0 && callbacks.left.size === 0) {
+          this.roomUserCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * Invoke a custom server-side handler
+   * 
+   * @example
+   * ```typescript
+   * const result = await baasix.realtime.invoke('game:roll-dice', { sides: 6 });
+   * console.log('Dice result:', result);
+   * ```
+   */
+  async invoke(event, payload) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("custom", { event, payload }, (response) => {
+        if (response.status === "success") {
+          resolve(response);
+        } else {
+          reject(new Error(response.message || "Custom event failed"));
+        }
+      });
+    });
+  }
+  setupRoomListeners(roomName) {
+    if (!this.roomCallbacks.has(roomName)) {
+      this.roomCallbacks.set(roomName, /* @__PURE__ */ new Map());
+    }
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+  }
+  cleanupRoomListeners(roomName) {
+    this.roomCallbacks.delete(roomName);
+    this.roomUserCallbacks.delete(roomName);
+  }
+  // ===================
+  // Channel (Room) API - Supabase-style
+  // ===================
+  /**
+   * 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) {
+    return new RealtimeChannel(this, collection);
+  }
+};
+var RealtimeChannel = class {
+  realtime;
+  collection;
+  handlers = /* @__PURE__ */ new Map();
+  unsubscribeFn = null;
+  constructor(realtime, collection) {
+    this.realtime = realtime;
+    this.collection = collection;
+  }
+  /**
+   * Add an event handler (chainable)
+   * 
+   * @param event - 'INSERT', 'UPDATE', 'DELETE', or '*' for all
+   * @param callback - Handler function
+   */
+  on(event, callback) {
+    const mappedEvent = this.mapEvent(event);
+    if (mappedEvent === "*") {
+      ["create", "update", "delete"].forEach((e) => {
+        this.addHandler(e, callback);
+      });
+    } else {
+      this.addHandler(mappedEvent, callback);
+    }
+    return this;
+  }
+  mapEvent(event) {
+    switch (event.toUpperCase()) {
+      case "INSERT":
+        return "create";
+      case "UPDATE":
+        return "update";
+      case "DELETE":
+        return "delete";
+      default:
+        return "*";
+    }
+  }
+  addHandler(event, callback) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, []);
+    }
+    this.handlers.get(event).push(callback);
+  }
+  /**
+   * Start the subscription
+   */
+  subscribe() {
+    this.unsubscribeFn = this.realtime.subscribe(this.collection, (payload) => {
+      const handlers = this.handlers.get(payload.action);
+      if (handlers) {
+        handlers.forEach((handler) => {
+          try {
+            handler(payload);
+          } catch (error) {
+            console.error("[Baasix Channel] Handler error:", error);
+          }
+        });
+      }
+    });
+    return this;
+  }
+  /**
+   * Stop the subscription
+   */
+  unsubscribe() {
+    if (this.unsubscribeFn) {
+      this.unsubscribeFn();
+      this.unsubscribeFn = null;
+    }
+    this.handlers.clear();
+  }
+};
+
+// src/modules/roles.ts
+var RolesModule = class {
+  client;
+  collection = "baasix_Role";
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Get all roles
+   * 
+   * @example
+   * ```typescript
+   * const { data: roles } = await baasix.roles.find();
+   * ```
+   */
+  async find() {
+    return this.client.get(
+      `/items/${this.collection}`,
+      {
+        params: { limit: -1 }
+      }
+    );
+  }
+  /**
+   * Get a role by ID
+   * 
+   * @example
+   * ```typescript
+   * const role = await baasix.roles.findOne('role-uuid');
+   * ```
+   */
+  async findOne(id) {
+    const response = await this.client.get(
+      `/items/${this.collection}/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get a role by name
+   * 
+   * @example
+   * ```typescript
+   * const role = await baasix.roles.findByName('Administrator');
+   * ```
+   */
+  async findByName(name) {
+    const response = await this.client.get(
+      `/items/${this.collection}`,
+      {
+        params: {
+          filter: JSON.stringify({ name: { eq: name } }),
+          limit: 1
+        }
+      }
+    );
+    return response.data[0] || null;
+  }
+  /**
+   * Create a new role
+   * 
+   * @example
+   * ```typescript
+   * const id = await baasix.roles.create({
+   *   name: 'Editor',
+   *   description: 'Content editor role',
+   *   appAccess: true
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      `/items/${this.collection}`,
+      data
+    );
+    return response.data.id;
+  }
+  /**
+   * Update a role
+   * 
+   * @example
+   * ```typescript
+   * await baasix.roles.update('role-uuid', {
+   *   description: 'Updated description'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    await this.client.patch(`/items/${this.collection}/${id}`, data);
+  }
+  /**
+   * Delete a role
+   * 
+   * @example
+   * ```typescript
+   * await baasix.roles.delete('role-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/items/${this.collection}/${id}`);
+  }
+};
+
+// src/modules/users.ts
+var UsersModule = class {
+  client;
+  collection = "baasix_User";
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Get all users with optional filtering
+   * 
+   * @example
+   * ```typescript
+   * const { data: users } = await baasix.users.find({
+   *   filter: { status: { eq: 'active' } },
+   *   limit: 20
+   * });
+   * ```
+   */
+  async find(options = {}) {
+    const params = {};
+    if (options.filter) {
+      params.filter = JSON.stringify(options.filter);
+    }
+    if (options.sort) {
+      params.sort = options.sort;
+    }
+    if (options.limit !== void 0) {
+      params.limit = options.limit;
+    }
+    if (options.page !== void 0) {
+      params.page = options.page;
+    }
+    if (options.fields?.length) {
+      params.fields = options.fields.join(",");
+    }
+    return this.client.get(
+      `/items/${this.collection}`,
+      { params }
+    );
+  }
+  /**
+   * Get a user by ID
+   * 
+   * @example
+   * ```typescript
+   * const user = await baasix.users.findOne('user-uuid');
+   * ```
+   */
+  async findOne(id, fields) {
+    const params = {};
+    if (fields?.length) {
+      params.fields = fields.join(",");
+    }
+    const response = await this.client.get(
+      `/items/${this.collection}/${id}`,
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Get a user by email
+   * 
+   * @example
+   * ```typescript
+   * const user = await baasix.users.findByEmail('user@example.com');
+   * ```
+   */
+  async findByEmail(email) {
+    const response = await this.client.get(
+      `/items/${this.collection}`,
+      {
+        params: {
+          filter: JSON.stringify({ email: { eq: email } }),
+          limit: 1
+        }
+      }
+    );
+    return response.data[0] || 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'
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post(
+      `/items/${this.collection}`,
+      data
+    );
+    return response.data.id;
+  }
+  /**
+   * Update a user
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.update('user-uuid', {
+   *   firstName: 'Jane'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    await this.client.patch(`/items/${this.collection}/${id}`, data);
+  }
+  /**
+   * Delete a user
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.delete('user-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/items/${this.collection}/${id}`);
+  }
+  /**
+   * Change a user's password (admin operation)
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.changePassword('user-uuid', 'newpassword');
+   * ```
+   */
+  async changePassword(userId, newPassword) {
+    await this.client.post("/auth/admin/change-password", {
+      userId,
+      password: newPassword
+    });
+  }
+  /**
+   * Suspend a user
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.suspend('user-uuid');
+   * ```
+   */
+  async suspend(id) {
+    await this.client.patch(`/items/${this.collection}/${id}`, {
+      status: "suspended"
+    });
+  }
+  /**
+   * Activate a user
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.activate('user-uuid');
+   * ```
+   */
+  async activate(id) {
+    await this.client.patch(`/items/${this.collection}/${id}`, {
+      status: "active"
+    });
+  }
+  /**
+   * 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' }
+   * ]);
+   * ```
+   */
+  async createMany(users) {
+    const response = await this.client.post(
+      `/items/${this.collection}/bulk`,
+      users
+    );
+    return response.data;
+  }
+  /**
+   * Bulk delete users
+   * 
+   * @example
+   * ```typescript
+   * await baasix.users.deleteMany(['user-uuid-1', 'user-uuid-2']);
+   * ```
+   */
+  async deleteMany(ids) {
+    await this.client.delete(`/items/${this.collection}/bulk`, {
+      body: JSON.stringify(ids)
+    });
+  }
+};
+
+// src/modules/migrations.ts
+var MigrationsModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Get migration status
+   * 
+   * @example
+   * ```typescript
+   * const status = await baasix.migrations.status();
+   * console.log(`Pending migrations: ${status.pendingCount}`);
+   * ```
+   */
+  async status() {
+    const response = await this.client.get(
+      "/migrations/status"
+    );
+    return response.data;
+  }
+  /**
+   * 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' });
+   * ```
+   */
+  async list(options) {
+    const response = await this.client.get("/migrations", {
+      params: options
+    });
+    return response.data;
+  }
+  /**
+   * Get pending migrations
+   * 
+   * @example
+   * ```typescript
+   * const pending = await baasix.migrations.pending();
+   * ```
+   */
+  async pending() {
+    const response = await this.client.get(
+      "/migrations/pending"
+    );
+    return response.data;
+  }
+  /**
+   * Check if migrations are needed
+   * 
+   * @example
+   * ```typescript
+   * const check = await baasix.migrations.check();
+   * if (check.hasPending) {
+   *   console.log('Migrations needed');
+   * }
+   * ```
+   */
+  async check() {
+    const response = await this.client.get(
+      "/migrations/check"
+    );
+    return response.data;
+  }
+  /**
+   * Get a specific migration by version
+   * 
+   * @example
+   * ```typescript
+   * const migration = await baasix.migrations.get('20231201000000');
+   * ```
+   */
+  async get(version) {
+    try {
+      const response = await this.client.get(
+        `/migrations/${encodeURIComponent(version)}`
+      );
+      return response.data;
+    } catch {
+      return 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
+   * });
+   * ```
+   */
+  async run(options) {
+    const response = await this.client.post(
+      "/migrations/run",
+      options || {}
+    );
+    return response.data;
+  }
+  /**
+   * Rollback a specific migration
+   * 
+   * @example
+   * ```typescript
+   * const result = await baasix.migrations.rollback('20231201000000');
+   * ```
+   */
+  async rollback(version) {
+    const response = await this.client.post(
+      `/migrations/rollback/${encodeURIComponent(version)}`,
+      {}
+    );
+    return response.data;
+  }
+  /**
+   * Rollback the last batch of migrations
+   * 
+   * @example
+   * ```typescript
+   * const result = await baasix.migrations.rollbackBatch();
+   * ```
+   */
+  async rollbackBatch() {
+    const response = await this.client.post(
+      "/migrations/rollback-batch",
+      {}
+    );
+    return response.data;
+  }
+  /**
+   * Create a new migration file
+   * 
+   * @example
+   * ```typescript
+   * const { filepath } = await baasix.migrations.create('add_status_column', {
+   *   type: 'schema',
+   *   description: 'Add status column to orders'
+   * });
+   * ```
+   */
+  async create(name, options) {
+    const response = await this.client.post(
+      "/migrations/create",
+      { name, ...options }
+    );
+    return response.data;
+  }
+  /**
+   * 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');
+   * ```
+   */
+  async markCompleted(version, metadata) {
+    const response = await this.client.post(
+      `/migrations/mark-completed/${encodeURIComponent(version)}`,
+      { metadata }
+    );
+    return response.data;
+  }
+  /**
+   * 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');
+   * ```
+   */
+  async markAllCompleted(toVersion) {
+    const response = await this.client.post(
+      "/migrations/mark-all-completed",
+      { toVersion }
+    );
+    return response.data;
+  }
+};
+
+// src/modules/server.ts
+var ServerModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async info() {
+    return this.client.get("/");
+  }
+  /**
+   * Check server health
+   *
+   * @example
+   * ```typescript
+   * const isHealthy = await baasix.server.health();
+   * ```
+   */
+  async health() {
+    try {
+      await this.client.get("/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/storage/asyncStorage.ts
+var AsyncStorageAdapter = class {
+  asyncStorage;
+  prefix;
+  constructor(asyncStorage, prefix = "baasix_") {
+    this.asyncStorage = asyncStorage;
+    this.prefix = prefix;
+  }
+  getKey(key) {
+    if (key.startsWith(this.prefix)) {
+      return key;
+    }
+    return `${this.prefix}${key}`;
+  }
+  async get(key) {
+    try {
+      return await this.asyncStorage.getItem(this.getKey(key));
+    } catch {
+      console.warn(`[Baasix SDK] Failed to get item from AsyncStorage: ${key}`);
+      return null;
+    }
+  }
+  async set(key, value) {
+    try {
+      await this.asyncStorage.setItem(this.getKey(key), value);
+    } catch {
+      console.warn(`[Baasix SDK] Failed to set item in AsyncStorage: ${key}`);
+    }
+  }
+  async remove(key) {
+    try {
+      await this.asyncStorage.removeItem(this.getKey(key));
+    } catch {
+      console.warn(`[Baasix SDK] Failed to remove item from AsyncStorage: ${key}`);
+    }
+  }
+  async clear() {
+    try {
+      if (this.asyncStorage.getAllKeys && this.asyncStorage.multiRemove) {
+        const allKeys = await this.asyncStorage.getAllKeys();
+        const sdkKeys = allKeys.filter((key) => key.startsWith(this.prefix));
+        if (sdkKeys.length > 0) {
+          await this.asyncStorage.multiRemove(sdkKeys);
+        }
+      }
+    } catch {
+      console.warn("[Baasix SDK] Failed to clear AsyncStorage");
+    }
+  }
+};
+
+// src/index.ts
+function getDefaultStorage() {
+  if (typeof window !== "undefined" && typeof window.localStorage !== "undefined") {
+    return new LocalStorageAdapter();
+  }
+  return new MemoryStorageAdapter();
+}
+var Baasix = class {
+  config;
+  httpClient;
+  storage;
+  // Modules
+  auth;
+  files;
+  schemas;
+  notifications;
+  permissions;
+  settings;
+  reports;
+  workflows;
+  realtime;
+  roles;
+  users;
+  migrations;
+  server;
+  // Items module factory cache
+  itemsModules = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (!config.url) {
+      throw new Error("Baasix SDK: url is required");
+    }
+    const normalizedUrl = config.url.replace(/\/$/, "");
+    this.config = {
+      ...config,
+      url: normalizedUrl,
+      authMode: config.authMode || "jwt",
+      timeout: config.timeout || 6e5,
+      // 10 minutes default
+      autoRefresh: config.autoRefresh !== false
+    };
+    this.storage = config.storage || getDefaultStorage();
+    const credentials = config.credentials || (this.config.authMode === "cookie" ? "include" : "same-origin");
+    this.httpClient = new HttpClient({
+      baseUrl: normalizedUrl,
+      authMode: this.config.authMode,
+      storage: this.storage,
+      timeout: this.config.timeout,
+      autoRefresh: this.config.autoRefresh,
+      credentials,
+      headers: config.headers || {},
+      token: config.token,
+      tenantId: config.tenantId,
+      onAuthError: () => {
+        this.config.onAuthStateChange?.("SIGNED_OUT", null);
+      },
+      onTokenRefresh: () => {
+      }
+    });
+    this.auth = new AuthModule({
+      client: this.httpClient,
+      storage: this.storage,
+      authMode: this.config.authMode,
+      onAuthStateChange: config.onAuthStateChange
+    });
+    this.files = new FilesModule({ client: this.httpClient });
+    this.schemas = new SchemasModule({ client: this.httpClient });
+    this.notifications = new NotificationsModule({ client: this.httpClient });
+    this.permissions = new PermissionsModule({ client: this.httpClient });
+    this.settings = new SettingsModule({ client: this.httpClient });
+    this.reports = new ReportsModule({ client: this.httpClient });
+    this.workflows = new WorkflowsModule({ client: this.httpClient });
+    this.roles = new RolesModule({ client: this.httpClient });
+    this.users = new UsersModule({ client: this.httpClient });
+    this.migrations = new MigrationsModule({ client: this.httpClient });
+    this.server = new ServerModule({ client: this.httpClient });
+    this.realtime = new RealtimeModule({
+      client: this.httpClient,
+      storage: this.storage,
+      socketUrl: config.socketUrl,
+      socketPath: config.socketPath
+    });
+  }
+  /**
+   * 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(collection) {
+    if (!this.itemsModules.has(collection)) {
+      this.itemsModules.set(
+        collection,
+        new ItemsModule(collection, { client: this.httpClient })
+      );
+    }
+    return this.itemsModules.get(collection);
+  }
+  /**
+   * Alias for items() - get a collection
+   *
+   * @example
+   * ```typescript
+   * const products = baasix.collection('products');
+   * ```
+   */
+  collection(collection) {
+    return this.items(collection);
+  }
+  /**
+   * Alias for items() - from a collection (Supabase-style)
+   *
+   * @example
+   * ```typescript
+   * const products = baasix.from('products');
+   * ```
+   */
+  from(collection) {
+    return this.items(collection);
+  }
+  /**
+   * 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() {
+    return this.httpClient;
+  }
+  /**
+   * Update SDK configuration
+   *
+   * @example
+   * ```typescript
+   * baasix.configure({
+   *   headers: { 'X-Custom-Header': 'value' }
+   * });
+   * ```
+   */
+  configure(config) {
+    if (config.headers) {
+      this.httpClient.updateConfig({ headers: config.headers });
+    }
+    if (config.tenantId !== void 0) {
+      this.httpClient.updateConfig({ tenantId: config.tenantId });
+    }
+    if (config.token) {
+      this.httpClient.updateConfig({ token: config.token });
+    }
+    if (config.timeout) {
+      this.httpClient.updateConfig({ timeout: config.timeout });
+    }
+  }
+  /**
+   * Set the tenant for multi-tenant mode
+   *
+   * @example
+   * ```typescript
+   * baasix.setTenant('tenant-uuid');
+   * ```
+   */
+  async setTenant(tenantId) {
+    this.httpClient.updateConfig({ tenantId });
+    await this.storage.set(STORAGE_KEYS.TENANT, tenantId);
+  }
+  /**
+   * Get the current tenant ID
+   */
+  async getTenant() {
+    return await this.storage.get(STORAGE_KEYS.TENANT);
+  }
+  /**
+   * Clear the tenant
+   */
+  async clearTenant() {
+    this.httpClient.updateConfig({ tenantId: void 0 });
+    await this.storage.remove(STORAGE_KEYS.TENANT);
+  }
+  /**
+   * Set a static token (convenience method that delegates to auth.setToken)
+   *
+   * @example
+   * ```typescript
+   * baasix.setToken('your-api-token');
+   * ```
+   */
+  async setToken(token) {
+    return this.auth.setToken(token);
+  }
+  /**
+   * Get the current auth token
+   */
+  async getToken() {
+    return this.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+  }
+  /**
+   * Get the base URL
+   */
+  getUrl() {
+    return this.config.url;
+  }
+  /**
+   * Get the current auth mode
+   */
+  getAuthMode() {
+    return this.config.authMode;
+  }
+  /**
+   * Get the storage adapter
+   */
+  getStorage() {
+    return this.storage;
+  }
+};
+function createBaasix(config) {
+  return new Baasix(config);
+}
+
+exports.AsyncStorageAdapter = AsyncStorageAdapter;
+exports.AuthModule = AuthModule;
+exports.Baasix = Baasix;
+exports.BaasixError = BaasixError;
+exports.FilesModule = FilesModule;
+exports.HttpClient = HttpClient;
+exports.ItemsModule = ItemsModule;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.MigrationsModule = MigrationsModule;
+exports.NotificationsModule = NotificationsModule;
+exports.PermissionsModule = PermissionsModule;
+exports.QueryBuilder = QueryBuilder;
+exports.RealtimeChannel = RealtimeChannel;
+exports.RealtimeModule = RealtimeModule;
+exports.ReportsModule = ReportsModule;
+exports.RolesModule = RolesModule;
+exports.STORAGE_KEYS = STORAGE_KEYS;
+exports.SchemasModule = SchemasModule;
+exports.SettingsModule = SettingsModule;
+exports.UsersModule = UsersModule;
+exports.WorkflowsModule = WorkflowsModule;
+exports.createBaasix = createBaasix;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map