@fluxbase/sdk 0.0.1-rc.2

package/dist/index.cjs

@@ -0,0 +1,3260 @@
+'use strict';
+
+// src/fetch.ts
+var FluxbaseFetch = class {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.timeout = options.timeout ?? 3e4;
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Update the authorization header
+   */
+  setAuthToken(token) {
+    if (token) {
+      this.defaultHeaders["Authorization"] = `Bearer ${token}`;
+    } else {
+      delete this.defaultHeaders["Authorization"];
+    }
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { ...this.defaultHeaders, ...options.headers };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? this.timeout);
+    if (this.debug) {
+      console.log(`[Fluxbase SDK] ${options.method} ${url}`, options.body);
+    }
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("content-type");
+      let data;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      if (this.debug) {
+        console.log(`[Fluxbase SDK] Response:`, response.status, data);
+      }
+      if (!response.ok) {
+        const error = new Error(
+          typeof data === "object" && data && "error" in data ? String(data.error) : response.statusText
+        );
+        error.status = response.status;
+        error.details = data;
+        throw error;
+      }
+      return data;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.status = 408;
+          throw timeoutError;
+        }
+        throw err;
+      }
+      throw new Error("Unknown error occurred");
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(path, options = {}) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, options = {}) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(path, body, options = {}) {
+    return this.request(path, { ...options, method: "PUT", body });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, options = {}) {
+    return this.request(path, { ...options, method: "PATCH", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, options = {}) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  /**
+   * HEAD request
+   */
+  async head(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { ...this.defaultHeaders, ...options.headers };
+    const response = await fetch(url, {
+      method: "HEAD",
+      headers
+    });
+    return response.headers;
+  }
+};
+
+// src/auth.ts
+var AUTH_STORAGE_KEY = "fluxbase.auth.session";
+var FluxbaseAuth = class {
+  constructor(fetch2, autoRefresh = true, persist = true) {
+    this.session = null;
+    this.refreshTimer = null;
+    this.stateChangeListeners = /* @__PURE__ */ new Set();
+    this.fetch = fetch2;
+    this.persist = persist;
+    this.autoRefresh = autoRefresh;
+    if (this.persist && typeof localStorage !== "undefined") {
+      const stored = localStorage.getItem(AUTH_STORAGE_KEY);
+      if (stored) {
+        try {
+          this.session = JSON.parse(stored);
+          if (this.session) {
+            this.fetch.setAuthToken(this.session.access_token);
+            this.scheduleTokenRefresh();
+          }
+        } catch {
+          localStorage.removeItem(AUTH_STORAGE_KEY);
+        }
+      }
+    }
+  }
+  /**
+   * Get the current session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Get the current user
+   */
+  getUser() {
+    return this.session?.user ?? null;
+  }
+  /**
+   * Get the current access token
+   */
+  getAccessToken() {
+    return this.session?.access_token ?? null;
+  }
+  /**
+   * Listen to auth state changes
+   * @param callback - Function called when auth state changes
+   * @returns Subscription object with unsubscribe method
+   *
+   * @example
+   * ```typescript
+   * const { data: { subscription } } = client.auth.onAuthStateChange((event, session) => {
+   *   console.log('Auth event:', event, session)
+   * })
+   *
+   * // Later, to unsubscribe:
+   * subscription.unsubscribe()
+   * ```
+   */
+  onAuthStateChange(callback) {
+    this.stateChangeListeners.add(callback);
+    return {
+      unsubscribe: () => {
+        this.stateChangeListeners.delete(callback);
+      }
+    };
+  }
+  /**
+   * Sign in with email and password
+   * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+   */
+  async signIn(credentials) {
+    const response = await this.fetch.post(
+      "/api/v1/auth/signin",
+      credentials
+    );
+    if ("requires_2fa" in response && response.requires_2fa) {
+      return response;
+    }
+    const authResponse = response;
+    const session = {
+      ...authResponse,
+      expires_at: Date.now() + authResponse.expires_in * 1e3
+    };
+    this.setSession(session);
+    return session;
+  }
+  /**
+   * Sign up with email and password
+   */
+  async signUp(credentials) {
+    const response = await this.fetch.post("/api/v1/auth/signup", credentials);
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session);
+    return session;
+  }
+  /**
+   * Sign out the current user
+   */
+  async signOut() {
+    try {
+      await this.fetch.post("/api/v1/auth/signout");
+    } finally {
+      this.clearSession();
+    }
+  }
+  /**
+   * Refresh the access token
+   */
+  async refreshToken() {
+    if (!this.session?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+    const response = await this.fetch.post("/api/v1/auth/refresh", {
+      refresh_token: this.session.refresh_token
+    });
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session, "TOKEN_REFRESHED");
+    return session;
+  }
+  /**
+   * Get the current user from the server
+   */
+  async getCurrentUser() {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    return await this.fetch.get("/api/v1/auth/user");
+  }
+  /**
+   * Update the current user
+   */
+  async updateUser(data) {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    const user = await this.fetch.patch("/api/v1/auth/user", data);
+    if (this.session) {
+      this.session.user = user;
+      this.saveSession();
+      this.emitAuthChange("USER_UPDATED", this.session);
+    }
+    return user;
+  }
+  /**
+   * Set the auth token manually
+   */
+  setToken(token) {
+    this.fetch.setAuthToken(token);
+  }
+  /**
+   * Setup 2FA for the current user
+   * Returns TOTP secret and QR code URL
+   */
+  async setup2FA() {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    return await this.fetch.post("/api/v1/auth/2fa/setup");
+  }
+  /**
+   * Enable 2FA after verifying the TOTP code
+   * Returns backup codes that should be saved by the user
+   */
+  async enable2FA(code) {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    return await this.fetch.post("/api/v1/auth/2fa/enable", { code });
+  }
+  /**
+   * Disable 2FA for the current user
+   * Requires password confirmation
+   */
+  async disable2FA(password) {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    return await this.fetch.post(
+      "/api/v1/auth/2fa/disable",
+      { password }
+    );
+  }
+  /**
+   * Check 2FA status for the current user
+   */
+  async get2FAStatus() {
+    if (!this.session) {
+      throw new Error("Not authenticated");
+    }
+    return await this.fetch.get("/api/v1/auth/2fa/status");
+  }
+  /**
+   * Verify 2FA code during login
+   * Call this after signIn returns requires_2fa: true
+   */
+  async verify2FA(request) {
+    const response = await this.fetch.post("/api/v1/auth/2fa/verify", request);
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session, "MFA_CHALLENGE_VERIFIED");
+    return session;
+  }
+  /**
+   * Send password reset email
+   * Sends a password reset link to the provided email address
+   * @param email - Email address to send reset link to
+   */
+  async sendPasswordReset(email) {
+    return await this.fetch.post("/api/v1/auth/password/reset", { email });
+  }
+  /**
+   * Verify password reset token
+   * Check if a password reset token is valid before allowing password reset
+   * @param token - Password reset token to verify
+   */
+  async verifyResetToken(token) {
+    return await this.fetch.post("/api/v1/auth/password/reset/verify", {
+      token
+    });
+  }
+  /**
+   * Reset password with token
+   * Complete the password reset process with a valid token
+   * @param token - Password reset token
+   * @param newPassword - New password to set
+   */
+  async resetPassword(token, newPassword) {
+    return await this.fetch.post("/api/v1/auth/password/reset/confirm", {
+      token,
+      new_password: newPassword
+    });
+  }
+  /**
+   * Send magic link for passwordless authentication
+   * @param email - Email address to send magic link to
+   * @param options - Optional configuration for magic link
+   */
+  async sendMagicLink(email, options) {
+    return await this.fetch.post("/api/v1/auth/magiclink", {
+      email,
+      redirect_to: options?.redirect_to
+    });
+  }
+  /**
+   * Verify magic link token and sign in
+   * @param token - Magic link token from email
+   */
+  async verifyMagicLink(token) {
+    const response = await this.fetch.post("/api/v1/auth/magiclink/verify", {
+      token
+    });
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session);
+    return session;
+  }
+  /**
+   * Sign in anonymously
+   * Creates a temporary anonymous user session
+   */
+  async signInAnonymously() {
+    const response = await this.fetch.post("/api/v1/auth/signin/anonymous");
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session);
+    return session;
+  }
+  /**
+   * Get list of enabled OAuth providers
+   */
+  async getOAuthProviders() {
+    return await this.fetch.get("/api/v1/auth/oauth/providers");
+  }
+  /**
+   * Get OAuth authorization URL for a provider
+   * @param provider - OAuth provider name (e.g., 'google', 'github')
+   * @param options - Optional OAuth configuration
+   */
+  async getOAuthUrl(provider, options) {
+    const params = new URLSearchParams();
+    if (options?.redirect_to) {
+      params.append("redirect_to", options.redirect_to);
+    }
+    if (options?.scopes && options.scopes.length > 0) {
+      params.append("scopes", options.scopes.join(","));
+    }
+    const queryString = params.toString();
+    const url = queryString ? `/api/v1/auth/oauth/${provider}/authorize?${queryString}` : `/api/v1/auth/oauth/${provider}/authorize`;
+    const response = await this.fetch.get(url);
+    return response;
+  }
+  /**
+   * Exchange OAuth authorization code for session
+   * This is typically called in your OAuth callback handler
+   * @param code - Authorization code from OAuth callback
+   */
+  async exchangeCodeForSession(code) {
+    const response = await this.fetch.post("/api/v1/auth/oauth/callback", { code });
+    const session = {
+      ...response,
+      expires_at: Date.now() + response.expires_in * 1e3
+    };
+    this.setSession(session);
+    return session;
+  }
+  /**
+   * Convenience method to initiate OAuth sign-in
+   * Redirects the user to the OAuth provider's authorization page
+   * @param provider - OAuth provider name (e.g., 'google', 'github')
+   * @param options - Optional OAuth configuration
+   */
+  async signInWithOAuth(provider, options) {
+    const { url } = await this.getOAuthUrl(provider, options);
+    if (typeof window !== "undefined") {
+      window.location.href = url;
+    } else {
+      throw new Error("signInWithOAuth can only be called in a browser environment");
+    }
+  }
+  /**
+   * Internal: Set the session and persist it
+   */
+  setSession(session, event = "SIGNED_IN") {
+    this.session = session;
+    this.fetch.setAuthToken(session.access_token);
+    this.saveSession();
+    this.scheduleTokenRefresh();
+    this.emitAuthChange(event, session);
+  }
+  /**
+   * Internal: Clear the session
+   */
+  clearSession() {
+    this.session = null;
+    this.fetch.setAuthToken(null);
+    if (this.persist && typeof localStorage !== "undefined") {
+      localStorage.removeItem(AUTH_STORAGE_KEY);
+    }
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    this.emitAuthChange("SIGNED_OUT", null);
+  }
+  /**
+   * Internal: Save session to storage
+   */
+  saveSession() {
+    if (this.persist && typeof localStorage !== "undefined" && this.session) {
+      localStorage.setItem(AUTH_STORAGE_KEY, JSON.stringify(this.session));
+    }
+  }
+  /**
+   * Internal: Schedule automatic token refresh
+   */
+  scheduleTokenRefresh() {
+    if (!this.autoRefresh || !this.session?.expires_at) {
+      return;
+    }
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+    const refreshAt = this.session.expires_at - 60 * 1e3;
+    const delay = refreshAt - Date.now();
+    if (delay > 0) {
+      this.refreshTimer = setTimeout(() => {
+        this.refreshToken().catch((err) => {
+          console.error("Failed to refresh token:", err);
+          this.clearSession();
+        });
+      }, delay);
+    }
+  }
+  /**
+   * Internal: Emit auth state change event to all listeners
+   */
+  emitAuthChange(event, session) {
+    this.stateChangeListeners.forEach((callback) => {
+      try {
+        callback(event, session);
+      } catch (error) {
+        console.error("Error in auth state change listener:", error);
+      }
+    });
+  }
+};
+
+// src/realtime.ts
+var RealtimeChannel = class {
+  constructor(url, channelName, token = null) {
+    this.ws = null;
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.subscriptionConfig = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectDelay = 1e3;
+    this.heartbeatInterval = null;
+    this.url = url;
+    this.channelName = channelName;
+    this.token = token;
+  }
+  // Implementation
+  on(event, configOrCallback, callback) {
+    if (event === "postgres_changes" && typeof configOrCallback !== "function") {
+      const config = configOrCallback;
+      this.subscriptionConfig = config;
+      const actualCallback = callback;
+      const eventType = config.event;
+      if (!this.callbacks.has(eventType)) {
+        this.callbacks.set(eventType, /* @__PURE__ */ new Set());
+      }
+      this.callbacks.get(eventType).add(actualCallback);
+    } else {
+      const actualEvent = event;
+      const actualCallback = configOrCallback;
+      if (!this.callbacks.has(actualEvent)) {
+        this.callbacks.set(actualEvent, /* @__PURE__ */ new Set());
+      }
+      this.callbacks.get(actualEvent).add(actualCallback);
+    }
+    return this;
+  }
+  /**
+   * Remove a callback
+   */
+  off(event, callback) {
+    const callbacks = this.callbacks.get(event);
+    if (callbacks) {
+      callbacks.delete(callback);
+    }
+    return this;
+  }
+  /**
+   * Subscribe to the channel
+   */
+  subscribe() {
+    this.connect();
+    return this;
+  }
+  /**
+   * Unsubscribe from the channel
+   */
+  unsubscribe() {
+    if (this.ws) {
+      this.send({
+        type: "unsubscribe",
+        channel: this.channelName
+      });
+      this.disconnect();
+    }
+  }
+  /**
+   * Internal: Connect to WebSocket
+   */
+  connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    const wsUrl = new URL(this.url);
+    wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+    wsUrl.pathname = "/realtime";
+    if (this.token) {
+      wsUrl.searchParams.set("token", this.token);
+    }
+    this.ws = new WebSocket(wsUrl.toString());
+    this.ws.onopen = () => {
+      console.log("[Fluxbase Realtime] Connected");
+      this.reconnectAttempts = 0;
+      const subscribeMessage = {
+        type: "subscribe",
+        channel: this.channelName
+      };
+      if (this.subscriptionConfig) {
+        subscribeMessage.config = this.subscriptionConfig;
+      }
+      this.send(subscribeMessage);
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        this.handleMessage(message);
+      } catch (err) {
+        console.error("[Fluxbase Realtime] Failed to parse message:", err);
+      }
+    };
+    this.ws.onerror = (error) => {
+      console.error("[Fluxbase Realtime] WebSocket error:", error);
+    };
+    this.ws.onclose = () => {
+      console.log("[Fluxbase Realtime] Disconnected");
+      this.stopHeartbeat();
+      this.attemptReconnect();
+    };
+  }
+  /**
+   * Internal: Disconnect WebSocket
+   */
+  disconnect() {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Internal: Send a message
+   */
+  send(message) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Internal: Handle incoming message
+   */
+  handleMessage(message) {
+    switch (message.type) {
+      case "heartbeat":
+        this.send({ type: "heartbeat" });
+        break;
+      case "broadcast":
+        if (message.payload) {
+          this.handleBroadcast(message.payload);
+        }
+        break;
+      case "ack":
+        console.log("[Fluxbase Realtime] Subscription acknowledged");
+        break;
+      case "error":
+        console.error("[Fluxbase Realtime] Error:", message.error);
+        break;
+    }
+  }
+  /**
+   * Internal: Handle broadcast message
+   */
+  handleBroadcast(payload) {
+    const callbacks = this.callbacks.get(payload.type);
+    if (callbacks) {
+      callbacks.forEach((callback) => callback(payload));
+    }
+    const wildcardCallbacks = this.callbacks.get("*");
+    if (wildcardCallbacks) {
+      wildcardCallbacks.forEach((callback) => callback(payload));
+    }
+  }
+  /**
+   * Internal: Start heartbeat interval
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      this.send({ type: "heartbeat" });
+    }, 3e4);
+  }
+  /**
+   * Internal: Stop heartbeat interval
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  /**
+   * Internal: Attempt to reconnect
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("[Fluxbase Realtime] Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    console.log(`[Fluxbase Realtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+};
+var FluxbaseRealtime = class {
+  constructor(url, token = null) {
+    this.channels = /* @__PURE__ */ new Map();
+    this.url = url;
+    this.token = token;
+  }
+  /**
+   * Create or get a channel
+   * @param channelName - Channel name (e.g., 'table:public.products')
+   */
+  channel(channelName) {
+    if (this.channels.has(channelName)) {
+      return this.channels.get(channelName);
+    }
+    const channel = new RealtimeChannel(this.url, channelName, this.token);
+    this.channels.set(channelName, channel);
+    return channel;
+  }
+  /**
+   * Remove all channels
+   */
+  removeAllChannels() {
+    this.channels.forEach((channel) => channel.unsubscribe());
+    this.channels.clear();
+  }
+  /**
+   * Update auth token for all channels
+   */
+  setToken(token) {
+    this.token = token;
+  }
+};
+
+// src/storage.ts
+var StorageBucket = class {
+  constructor(fetch2, bucketName) {
+    this.fetch = fetch2;
+    this.bucketName = bucketName;
+  }
+  /**
+   * Upload a file to the bucket
+   * @param path - The path/key for the file
+   * @param file - The file to upload (File, Blob, or ArrayBuffer)
+   * @param options - Upload options
+   */
+  async upload(path, file, options) {
+    try {
+      const formData = new FormData();
+      const blob = file instanceof ArrayBuffer ? new Blob([file]) : file;
+      formData.append("file", blob);
+      if (options?.contentType) {
+        formData.append("content_type", options.contentType);
+      }
+      if (options?.metadata) {
+        formData.append("metadata", JSON.stringify(options.metadata));
+      }
+      if (options?.cacheControl) {
+        formData.append("cache_control", options.cacheControl);
+      }
+      if (options?.upsert !== void 0) {
+        formData.append("upsert", String(options.upsert));
+      }
+      const data = await this.fetch.request(
+        `/api/v1/storage/${this.bucketName}/${path}`,
+        {
+          method: "POST",
+          body: formData,
+          headers: {}
+          // Let browser set Content-Type for FormData
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Download a file from the bucket
+   * @param path - The path/key of the file
+   */
+  async download(path) {
+    try {
+      const response = await fetch(
+        `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`,
+        {
+          headers: this.fetch["defaultHeaders"]
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.statusText}`);
+      }
+      const blob = await response.blob();
+      return { data: blob, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List files in the bucket
+   * @param options - List options (prefix, limit, offset)
+   */
+  async list(options) {
+    try {
+      const params = new URLSearchParams();
+      if (options?.prefix) {
+        params.set("prefix", options.prefix);
+      }
+      if (options?.limit) {
+        params.set("limit", String(options.limit));
+      }
+      if (options?.offset) {
+        params.set("offset", String(options.offset));
+      }
+      const queryString = params.toString();
+      const path = `/api/v1/storage/${this.bucketName}${queryString ? `?${queryString}` : ""}`;
+      const data = await this.fetch.get(path);
+      return { data: data.objects || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Remove files from the bucket
+   * @param paths - Array of file paths to remove
+   */
+  async remove(paths) {
+    try {
+      for (const path of paths) {
+        await this.fetch.delete(`/api/v1/storage/${this.bucketName}/${path}`);
+      }
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get a public URL for a file
+   * @param path - The file path
+   */
+  getPublicUrl(path) {
+    const publicUrl = `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`;
+    return { data: { publicUrl } };
+  }
+  /**
+   * Create a signed URL for temporary access to a file
+   * @param path - The file path
+   * @param options - Signed URL options
+   */
+  async createSignedUrl(path, options) {
+    try {
+      const expiresIn = options?.expiresIn || 3600;
+      const data = await this.fetch.post(
+        `/api/v1/storage/${this.bucketName}/sign/${path}`,
+        { expires_in: expiresIn }
+      );
+      return { data: { signedUrl: data.signed_url }, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Move a file to a new location
+   * @param fromPath - Current file path
+   * @param toPath - New file path
+   */
+  async move(fromPath, toPath) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/storage/${this.bucketName}/move`,
+        {
+          from_path: fromPath,
+          to_path: toPath
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Copy a file to a new location
+   * @param fromPath - Source file path
+   * @param toPath - Destination file path
+   */
+  async copy(fromPath, toPath) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/storage/${this.bucketName}/copy`,
+        {
+          from_path: fromPath,
+          to_path: toPath
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+var FluxbaseStorage = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Get a reference to a storage bucket
+   * @param bucketName - The name of the bucket
+   */
+  from(bucketName) {
+    return new StorageBucket(this.fetch, bucketName);
+  }
+  /**
+   * List all buckets
+   */
+  async listBuckets() {
+    try {
+      const data = await this.fetch.get(
+        "/api/v1/storage/buckets"
+      );
+      return { data: data.buckets || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new bucket
+   * @param bucketName - The name of the bucket to create
+   */
+  async createBucket(bucketName) {
+    try {
+      await this.fetch.post(`/api/v1/storage/buckets/${bucketName}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a bucket
+   * @param bucketName - The name of the bucket to delete
+   */
+  async deleteBucket(bucketName) {
+    try {
+      await this.fetch.delete(`/api/v1/storage/buckets/${bucketName}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Empty a bucket (delete all files)
+   * @param bucketName - The name of the bucket to empty
+   */
+  async emptyBucket(bucketName) {
+    try {
+      const bucket = this.from(bucketName);
+      const { data: objects, error: listError } = await bucket.list();
+      if (listError) {
+        return { data: null, error: listError };
+      }
+      if (objects && objects.length > 0) {
+        const paths = objects.map((obj) => obj.key);
+        const { error: removeError } = await bucket.remove(paths);
+        if (removeError) {
+          return { data: null, error: removeError };
+        }
+      }
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/settings.ts
+var SystemSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List all system settings
+   *
+   * @returns Promise resolving to ListSystemSettingsResponse
+   *
+   * @example
+   * ```typescript
+   * const response = await client.admin.settings.system.list()
+   * console.log(response.settings)
+   * ```
+   */
+  async list() {
+    const settings = await this.fetch.get("/api/v1/admin/system/settings");
+    return { settings: Array.isArray(settings) ? settings : [] };
+  }
+  /**
+   * Get a specific system setting by key
+   *
+   * @param key - Setting key (e.g., 'app.auth.enable_signup')
+   * @returns Promise resolving to SystemSetting
+   *
+   * @example
+   * ```typescript
+   * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
+   * console.log(setting.value)
+   * ```
+   */
+  async get(key) {
+    return await this.fetch.get(`/api/v1/admin/system/settings/${key}`);
+  }
+  /**
+   * Update or create a system setting
+   *
+   * @param key - Setting key
+   * @param request - Update request with value and optional description
+   * @returns Promise resolving to SystemSetting
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.admin.settings.system.update('app.auth.enable_signup', {
+   *   value: { value: true },
+   *   description: 'Enable user signup'
+   * })
+   * ```
+   */
+  async update(key, request) {
+    return await this.fetch.put(`/api/v1/admin/system/settings/${key}`, request);
+  }
+  /**
+   * Delete a system setting
+   *
+   * @param key - Setting key to delete
+   * @returns Promise<void>
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.system.delete('app.auth.enable_signup')
+   * ```
+   */
+  async delete(key) {
+    await this.fetch.delete(`/api/v1/admin/system/settings/${key}`);
+  }
+};
+var AppSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Get all application settings
+   *
+   * Returns structured settings for authentication, features, email, and security.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * const settings = await client.admin.settings.app.get()
+   *
+   * console.log('Signup enabled:', settings.authentication.enable_signup)
+   * console.log('Realtime enabled:', settings.features.enable_realtime)
+   * console.log('Email provider:', settings.email.provider)
+   * ```
+   */
+  async get() {
+    return await this.fetch.get("/api/v1/admin/app/settings");
+  }
+  /**
+   * Update application settings
+   *
+   * Supports partial updates - only provide the fields you want to change.
+   *
+   * @param request - Settings to update (partial update supported)
+   * @returns Promise resolving to AppSettings - Updated settings
+   *
+   * @example
+   * ```typescript
+   * // Update authentication settings
+   * const updated = await client.admin.settings.app.update({
+   *   authentication: {
+   *     enable_signup: true,
+   *     password_min_length: 12
+   *   }
+   * })
+   *
+   * // Update multiple categories
+   * await client.admin.settings.app.update({
+   *   authentication: { enable_signup: false },
+   *   features: { enable_realtime: true },
+   *   security: { enable_global_rate_limit: true }
+   * })
+   * ```
+   */
+  async update(request) {
+    return await this.fetch.put("/api/v1/admin/app/settings", request);
+  }
+  /**
+   * Reset all application settings to defaults
+   *
+   * This will delete all custom settings and return to default values.
+   *
+   * @returns Promise resolving to AppSettings - Default settings
+   *
+   * @example
+   * ```typescript
+   * const defaults = await client.admin.settings.app.reset()
+   * console.log('Settings reset to defaults:', defaults)
+   * ```
+   */
+  async reset() {
+    return await this.fetch.post("/api/v1/admin/app/settings/reset", {});
+  }
+  /**
+   * Enable user signup
+   *
+   * Convenience method to enable user registration.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.enableSignup()
+   * ```
+   */
+  async enableSignup() {
+    return await this.update({
+      authentication: { enable_signup: true }
+    });
+  }
+  /**
+   * Disable user signup
+   *
+   * Convenience method to disable user registration.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.disableSignup()
+   * ```
+   */
+  async disableSignup() {
+    return await this.update({
+      authentication: { enable_signup: false }
+    });
+  }
+  /**
+   * Update password minimum length
+   *
+   * Convenience method to set password requirements.
+   *
+   * @param length - Minimum password length (8-128 characters)
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.setPasswordMinLength(12)
+   * ```
+   */
+  async setPasswordMinLength(length) {
+    if (length < 8 || length > 128) {
+      throw new Error("Password minimum length must be between 8 and 128 characters");
+    }
+    return await this.update({
+      authentication: { password_min_length: length }
+    });
+  }
+  /**
+   * Enable or disable a feature
+   *
+   * Convenience method to toggle feature flags.
+   *
+   * @param feature - Feature name ('realtime' | 'storage' | 'functions')
+   * @param enabled - Whether to enable or disable the feature
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * // Enable realtime
+   * await client.admin.settings.app.setFeature('realtime', true)
+   *
+   * // Disable storage
+   * await client.admin.settings.app.setFeature('storage', false)
+   * ```
+   */
+  async setFeature(feature, enabled) {
+    const featureKey = feature === "realtime" ? "enable_realtime" : feature === "storage" ? "enable_storage" : "enable_functions";
+    return await this.update({
+      features: { [featureKey]: enabled }
+    });
+  }
+  /**
+   * Enable or disable global rate limiting
+   *
+   * Convenience method to toggle global rate limiting.
+   *
+   * @param enabled - Whether to enable rate limiting
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.setRateLimiting(true)
+   * ```
+   */
+  async setRateLimiting(enabled) {
+    return await this.update({
+      security: { enable_global_rate_limit: enabled }
+    });
+  }
+};
+var FluxbaseSettings = class {
+  constructor(fetch2) {
+    this.system = new SystemSettingsManager(fetch2);
+    this.app = new AppSettingsManager(fetch2);
+  }
+};
+
+// src/ddl.ts
+var DDLManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Create a new database schema
+   *
+   * Creates a new schema in the database. Schemas are used to organize tables
+   * into logical groups and provide namespace isolation.
+   *
+   * @param name - Schema name (must be valid PostgreSQL identifier)
+   * @returns Promise resolving to CreateSchemaResponse
+   *
+   * @example
+   * ```typescript
+   * // Create a schema for analytics data
+   * const result = await client.admin.ddl.createSchema('analytics')
+   * console.log(result.message) // "Schema created successfully"
+   * console.log(result.schema)  // "analytics"
+   * ```
+   */
+  async createSchema(name) {
+    const request = { name };
+    return await this.fetch.post("/api/v1/admin/ddl/schemas", request);
+  }
+  /**
+   * List all database schemas
+   *
+   * Retrieves a list of all schemas in the database. This includes both
+   * system schemas (like 'public', 'pg_catalog') and user-created schemas.
+   *
+   * @returns Promise resolving to ListSchemasResponse
+   *
+   * @example
+   * ```typescript
+   * const { schemas } = await client.admin.ddl.listSchemas()
+   *
+   * schemas.forEach(schema => {
+   *   console.log(`Schema: ${schema.name}, Owner: ${schema.owner}`)
+   * })
+   * ```
+   */
+  async listSchemas() {
+    return await this.fetch.get("/api/v1/admin/ddl/schemas");
+  }
+  /**
+   * Create a new table in a schema
+   *
+   * Creates a new table with the specified columns. Supports various column
+   * options including primary keys, nullability, data types, and default values.
+   *
+   * @param schema - Schema name where the table will be created
+   * @param name - Table name (must be valid PostgreSQL identifier)
+   * @param columns - Array of column definitions
+   * @returns Promise resolving to CreateTableResponse
+   *
+   * @example
+   * ```typescript
+   * // Create a users table
+   * await client.admin.ddl.createTable('public', 'users', [
+   *   {
+   *     name: 'id',
+   *     type: 'UUID',
+   *     primaryKey: true,
+   *     defaultValue: 'gen_random_uuid()'
+   *   },
+   *   {
+   *     name: 'email',
+   *     type: 'TEXT',
+   *     nullable: false
+   *   },
+   *   {
+   *     name: 'name',
+   *     type: 'TEXT'
+   *   },
+   *   {
+   *     name: 'created_at',
+   *     type: 'TIMESTAMPTZ',
+   *     nullable: false,
+   *     defaultValue: 'NOW()'
+   *   }
+   * ])
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Create a products table with JSONB metadata
+   * await client.admin.ddl.createTable('public', 'products', [
+   *   { name: 'id', type: 'SERIAL', primaryKey: true },
+   *   { name: 'name', type: 'TEXT', nullable: false },
+   *   { name: 'price', type: 'DECIMAL(10,2)', nullable: false },
+   *   { name: 'metadata', type: 'JSONB' },
+   *   { name: 'in_stock', type: 'BOOLEAN', defaultValue: 'true' }
+   * ])
+   * ```
+   */
+  async createTable(schema, name, columns) {
+    const request = { schema, name, columns };
+    return await this.fetch.post("/api/v1/admin/ddl/tables", request);
+  }
+  /**
+   * List all tables in the database or a specific schema
+   *
+   * Retrieves a list of all tables. If a schema is specified, only tables
+   * from that schema are returned. Otherwise, all tables from all schemas
+   * are returned.
+   *
+   * @param schema - Optional schema name to filter tables
+   * @returns Promise resolving to ListTablesResponse
+   *
+   * @example
+   * ```typescript
+   * // List all tables in the public schema
+   * const { tables } = await client.admin.ddl.listTables('public')
+   *
+   * tables.forEach(table => {
+   *   console.log(`Table: ${table.schema}.${table.name}`)
+   *   table.columns?.forEach(col => {
+   *     console.log(`  - ${col.name}: ${col.type}`)
+   *   })
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // List all tables across all schemas
+   * const { tables } = await client.admin.ddl.listTables()
+   *
+   * const tablesBySchema = tables.reduce((acc, table) => {
+   *   if (!acc[table.schema]) acc[table.schema] = []
+   *   acc[table.schema].push(table.name)
+   *   return acc
+   * }, {} as Record<string, string[]>)
+   *
+   * console.log(tablesBySchema)
+   * ```
+   */
+  async listTables(schema) {
+    const params = schema ? `?schema=${encodeURIComponent(schema)}` : "";
+    return await this.fetch.get(`/api/v1/admin/ddl/tables${params}`);
+  }
+  /**
+   * Delete a table from a schema
+   *
+   * Permanently deletes a table and all its data. This operation cannot be undone.
+   *
+   * @param schema - Schema name containing the table
+   * @param name - Table name to delete
+   * @returns Promise resolving to DeleteTableResponse
+   *
+   * @example
+   * ```typescript
+   * // Delete a table
+   * const result = await client.admin.ddl.deleteTable('public', 'old_data')
+   * console.log(result.message) // "Table deleted successfully"
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Safe deletion with confirmation
+   * const confirm = await askUser('Are you sure you want to delete this table?')
+   * if (confirm) {
+   *   await client.admin.ddl.deleteTable('analytics', 'events')
+   *   console.log('Table deleted')
+   * }
+   * ```
+   */
+  async deleteTable(schema, name) {
+    return await this.fetch.delete(
+      `/api/v1/admin/ddl/tables/${encodeURIComponent(schema)}/${encodeURIComponent(name)}`
+    );
+  }
+};
+
+// src/oauth.ts
+var OAuthProviderManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List all OAuth providers
+   *
+   * Retrieves all configured OAuth providers including both enabled and disabled providers.
+   * Note: Client secrets are not included in the response for security reasons.
+   *
+   * @returns Promise resolving to ListOAuthProvidersResponse
+   *
+   * @example
+   * ```typescript
+   * const { providers } = await client.admin.oauth.listProviders()
+   *
+   * providers.forEach(provider => {
+   *   console.log(`${provider.display_name}: ${provider.enabled ? 'enabled' : 'disabled'}`)
+   * })
+   * ```
+   */
+  async listProviders() {
+    const providers = await this.fetch.get("/api/v1/admin/oauth/providers");
+    return Array.isArray(providers) ? providers : [];
+  }
+  /**
+   * Get a specific OAuth provider by ID
+   *
+   * Retrieves detailed configuration for a single OAuth provider.
+   * Note: Client secret is not included in the response.
+   *
+   * @param providerId - Provider ID (UUID)
+   * @returns Promise resolving to OAuthProvider
+   *
+   * @example
+   * ```typescript
+   * const provider = await client.admin.oauth.getProvider('provider-uuid')
+   *
+   * console.log('Provider:', provider.display_name)
+   * console.log('Scopes:', provider.scopes.join(', '))
+   * console.log('Redirect URL:', provider.redirect_url)
+   * ```
+   */
+  async getProvider(providerId) {
+    return await this.fetch.get(`/api/v1/admin/oauth/providers/${providerId}`);
+  }
+  /**
+   * Create a new OAuth provider
+   *
+   * Creates a new OAuth provider configuration. For built-in providers (Google, GitHub, etc.),
+   * set `is_custom` to false. For custom OAuth2 providers, set `is_custom` to true and provide
+   * the authorization, token, and user info URLs.
+   *
+   * @param request - OAuth provider configuration
+   * @returns Promise resolving to CreateOAuthProviderResponse
+   *
+   * @example
+   * ```typescript
+   * // Create GitHub provider
+   * const result = await client.admin.oauth.createProvider({
+   *   provider_name: 'github',
+   *   display_name: 'GitHub',
+   *   enabled: true,
+   *   client_id: process.env.GITHUB_CLIENT_ID,
+   *   client_secret: process.env.GITHUB_CLIENT_SECRET,
+   *   redirect_url: 'https://yourapp.com/auth/callback',
+   *   scopes: ['user:email', 'read:user'],
+   *   is_custom: false
+   * })
+   *
+   * console.log('Provider created:', result.id)
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Create custom OAuth2 provider
+   * await client.admin.oauth.createProvider({
+   *   provider_name: 'custom_sso',
+   *   display_name: 'Custom SSO',
+   *   enabled: true,
+   *   client_id: 'client-id',
+   *   client_secret: 'client-secret',
+   *   redirect_url: 'https://yourapp.com/auth/callback',
+   *   scopes: ['openid', 'profile', 'email'],
+   *   is_custom: true,
+   *   authorization_url: 'https://sso.example.com/oauth/authorize',
+   *   token_url: 'https://sso.example.com/oauth/token',
+   *   user_info_url: 'https://sso.example.com/oauth/userinfo'
+   * })
+   * ```
+   */
+  async createProvider(request) {
+    return await this.fetch.post("/api/v1/admin/oauth/providers", request);
+  }
+  /**
+   * Update an existing OAuth provider
+   *
+   * Updates an OAuth provider configuration. All fields are optional - only provided fields
+   * will be updated. To update the client secret, provide a non-empty value.
+   *
+   * @param providerId - Provider ID (UUID)
+   * @param request - Fields to update
+   * @returns Promise resolving to UpdateOAuthProviderResponse
+   *
+   * @example
+   * ```typescript
+   * // Disable a provider
+   * await client.admin.oauth.updateProvider('provider-id', {
+   *   enabled: false
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Update scopes and redirect URL
+   * await client.admin.oauth.updateProvider('provider-id', {
+   *   scopes: ['user:email', 'read:user', 'read:org'],
+   *   redirect_url: 'https://newdomain.com/auth/callback'
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Rotate client secret
+   * await client.admin.oauth.updateProvider('provider-id', {
+   *   client_id: 'new-client-id',
+   *   client_secret: 'new-client-secret'
+   * })
+   * ```
+   */
+  async updateProvider(providerId, request) {
+    return await this.fetch.put(
+      `/api/v1/admin/oauth/providers/${providerId}`,
+      request
+    );
+  }
+  /**
+   * Delete an OAuth provider
+   *
+   * Permanently deletes an OAuth provider configuration. This will prevent users from
+   * authenticating with this provider.
+   *
+   * @param providerId - Provider ID (UUID) to delete
+   * @returns Promise resolving to DeleteOAuthProviderResponse
+   *
+   * @example
+   * ```typescript
+   * await client.admin.oauth.deleteProvider('provider-id')
+   * console.log('Provider deleted')
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Safe deletion with confirmation
+   * const provider = await client.admin.oauth.getProvider('provider-id')
+   * const confirmed = await confirm(`Delete ${provider.display_name}?`)
+   *
+   * if (confirmed) {
+   *   await client.admin.oauth.deleteProvider('provider-id')
+   * }
+   * ```
+   */
+  async deleteProvider(providerId) {
+    return await this.fetch.delete(
+      `/api/v1/admin/oauth/providers/${providerId}`
+    );
+  }
+  /**
+   * Enable an OAuth provider
+   *
+   * Convenience method to enable a provider.
+   *
+   * @param providerId - Provider ID (UUID)
+   * @returns Promise resolving to UpdateOAuthProviderResponse
+   *
+   * @example
+   * ```typescript
+   * await client.admin.oauth.enableProvider('provider-id')
+   * ```
+   */
+  async enableProvider(providerId) {
+    return await this.updateProvider(providerId, { enabled: true });
+  }
+  /**
+   * Disable an OAuth provider
+   *
+   * Convenience method to disable a provider.
+   *
+   * @param providerId - Provider ID (UUID)
+   * @returns Promise resolving to UpdateOAuthProviderResponse
+   *
+   * @example
+   * ```typescript
+   * await client.admin.oauth.disableProvider('provider-id')
+   * ```
+   */
+  async disableProvider(providerId) {
+    return await this.updateProvider(providerId, { enabled: false });
+  }
+};
+var AuthSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Get current authentication settings
+   *
+   * Retrieves all authentication configuration settings.
+   *
+   * @returns Promise resolving to AuthSettings
+   *
+   * @example
+   * ```typescript
+   * const settings = await client.admin.authSettings.get()
+   *
+   * console.log('Password min length:', settings.password_min_length)
+   * console.log('Signup enabled:', settings.enable_signup)
+   * console.log('Session timeout:', settings.session_timeout_minutes, 'minutes')
+   * ```
+   */
+  async get() {
+    return await this.fetch.get("/api/v1/admin/auth/settings");
+  }
+  /**
+   * Update authentication settings
+   *
+   * Updates one or more authentication settings. All fields are optional - only provided
+   * fields will be updated.
+   *
+   * @param request - Settings to update
+   * @returns Promise resolving to UpdateAuthSettingsResponse
+   *
+   * @example
+   * ```typescript
+   * // Strengthen password requirements
+   * await client.admin.authSettings.update({
+   *   password_min_length: 16,
+   *   password_require_uppercase: true,
+   *   password_require_lowercase: true,
+   *   password_require_number: true,
+   *   password_require_special: true
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Extend session timeout
+   * await client.admin.authSettings.update({
+   *   session_timeout_minutes: 240,
+   *   max_sessions_per_user: 10
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Disable email verification during development
+   * await client.admin.authSettings.update({
+   *   require_email_verification: false
+   * })
+   * ```
+   */
+  async update(request) {
+    return await this.fetch.put("/api/v1/admin/auth/settings", request);
+  }
+};
+var FluxbaseOAuth = class {
+  constructor(fetch2) {
+    this.providers = new OAuthProviderManager(fetch2);
+    this.authSettings = new AuthSettingsManager(fetch2);
+  }
+};
+
+// src/impersonation.ts
+var ImpersonationManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Impersonate a specific user
+   *
+   * Start an impersonation session as a specific user. This allows you to see data
+   * exactly as that user would see it, respecting all RLS policies and permissions.
+   *
+   * @param request - Impersonation request with target user ID and reason
+   * @returns Promise resolving to impersonation session with access token
+   *
+   * @example
+   * ```typescript
+   * const result = await client.admin.impersonation.impersonateUser({
+   *   target_user_id: 'user-123',
+   *   reason: 'Support ticket #5678 - user reports missing data'
+   * })
+   *
+   * console.log('Impersonating:', result.target_user.email)
+   * console.log('Session ID:', result.session.id)
+   *
+   * // Use the access token for subsequent requests
+   * // (typically handled automatically by the SDK)
+   * ```
+   */
+  async impersonateUser(request) {
+    return await this.fetch.post("/api/v1/auth/impersonate", request);
+  }
+  /**
+   * Impersonate anonymous user
+   *
+   * Start an impersonation session as an unauthenticated user. This allows you to see
+   * what data is publicly accessible and test RLS policies for anonymous access.
+   *
+   * @param request - Impersonation request with reason
+   * @returns Promise resolving to impersonation session with access token
+   *
+   * @example
+   * ```typescript
+   * await client.admin.impersonation.impersonateAnon({
+   *   reason: 'Testing public data access for blog posts'
+   * })
+   *
+   * // Now all queries will use anonymous permissions
+   * const publicPosts = await client.from('posts').select('*')
+   * console.log('Public posts:', publicPosts.length)
+   * ```
+   */
+  async impersonateAnon(request) {
+    return await this.fetch.post("/api/v1/auth/impersonate/anon", request);
+  }
+  /**
+   * Impersonate with service role
+   *
+   * Start an impersonation session with service-level permissions. This provides elevated
+   * access that may bypass RLS policies, useful for administrative operations.
+   *
+   * @param request - Impersonation request with reason
+   * @returns Promise resolving to impersonation session with access token
+   *
+   * @example
+   * ```typescript
+   * await client.admin.impersonation.impersonateService({
+   *   reason: 'Administrative data cleanup'
+   * })
+   *
+   * // Now all queries will use service role permissions
+   * const allRecords = await client.from('sensitive_data').select('*')
+   * console.log('All records:', allRecords.length)
+   * ```
+   */
+  async impersonateService(request) {
+    return await this.fetch.post("/api/v1/auth/impersonate/service", request);
+  }
+  /**
+   * Stop impersonation
+   *
+   * Ends the current impersonation session and returns to admin context.
+   * The session is marked as ended in the audit trail.
+   *
+   * @returns Promise resolving to stop confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.admin.impersonation.stop()
+   * console.log('Impersonation ended')
+   *
+   * // Subsequent queries will use admin permissions
+   * ```
+   */
+  async stop() {
+    return await this.fetch.delete("/api/v1/auth/impersonate");
+  }
+  /**
+   * Get current impersonation session
+   *
+   * Retrieves information about the active impersonation session, if any.
+   *
+   * @returns Promise resolving to current impersonation session or null
+   *
+   * @example
+   * ```typescript
+   * const current = await client.admin.impersonation.getCurrent()
+   *
+   * if (current.session) {
+   *   console.log('Currently impersonating:', current.target_user?.email)
+   *   console.log('Reason:', current.session.reason)
+   *   console.log('Started:', current.session.started_at)
+   * } else {
+   *   console.log('No active impersonation')
+   * }
+   * ```
+   */
+  async getCurrent() {
+    return await this.fetch.get("/api/v1/auth/impersonate");
+  }
+  /**
+   * List impersonation sessions (audit trail)
+   *
+   * Retrieves a list of impersonation sessions for audit and compliance purposes.
+   * Can be filtered by admin user, target user, type, and active status.
+   *
+   * @param options - Filter and pagination options
+   * @returns Promise resolving to list of impersonation sessions
+   *
+   * @example
+   * ```typescript
+   * // List all sessions
+   * const { sessions, total } = await client.admin.impersonation.listSessions()
+   * console.log(`Total sessions: ${total}`)
+   *
+   * // List active sessions only
+   * const active = await client.admin.impersonation.listSessions({
+   *   is_active: true
+   * })
+   * console.log('Active sessions:', active.sessions.length)
+   *
+   * // List sessions for a specific admin
+   * const adminSessions = await client.admin.impersonation.listSessions({
+   *   admin_user_id: 'admin-uuid',
+   *   limit: 50
+   * })
+   *
+   * // List user impersonation sessions only
+   * const userSessions = await client.admin.impersonation.listSessions({
+   *   impersonation_type: 'user',
+   *   offset: 0,
+   *   limit: 100
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Audit trail: Find who impersonated a specific user
+   * const userHistory = await client.admin.impersonation.listSessions({
+   *   target_user_id: 'user-uuid'
+   * })
+   *
+   * userHistory.sessions.forEach(session => {
+   *   console.log(`Admin ${session.admin_user_id} impersonated user`)
+   *   console.log(`Reason: ${session.reason}`)
+   *   console.log(`Duration: ${session.started_at} - ${session.ended_at}`)
+   * })
+   * ```
+   */
+  async listSessions(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) {
+      params.append("limit", String(options.limit));
+    }
+    if (options.offset !== void 0) {
+      params.append("offset", String(options.offset));
+    }
+    if (options.admin_user_id) {
+      params.append("admin_user_id", options.admin_user_id);
+    }
+    if (options.target_user_id) {
+      params.append("target_user_id", options.target_user_id);
+    }
+    if (options.impersonation_type) {
+      params.append("impersonation_type", options.impersonation_type);
+    }
+    if (options.is_active !== void 0) {
+      params.append("is_active", String(options.is_active));
+    }
+    const queryString = params.toString();
+    const url = queryString ? `/api/v1/auth/impersonate/sessions?${queryString}` : "/api/v1/auth/impersonate/sessions";
+    return await this.fetch.get(url);
+  }
+};
+
+// src/management.ts
+var APIKeysManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Create a new API key
+   *
+   * @param request - API key configuration
+   * @returns Created API key with the full key value (only shown once)
+   *
+   * @example
+   * ```typescript
+   * const { api_key, key } = await client.management.apiKeys.create({
+   *   name: 'Production Service',
+   *   description: 'API key for production service',
+   *   scopes: ['read:users', 'write:users'],
+   *   rate_limit_per_minute: 100,
+   *   expires_at: '2025-12-31T23:59:59Z'
+   * })
+   *
+   * // Store the key securely - it won't be shown again
+   * console.log('API Key:', key)
+   * ```
+   */
+  async create(request) {
+    return await this.fetch.post("/api/v1/api-keys", request);
+  }
+  /**
+   * List all API keys for the authenticated user
+   *
+   * @returns List of API keys (without full key values)
+   *
+   * @example
+   * ```typescript
+   * const { api_keys, total } = await client.management.apiKeys.list()
+   *
+   * api_keys.forEach(key => {
+   *   console.log(`${key.name}: ${key.key_prefix}... (expires: ${key.expires_at})`)
+   * })
+   * ```
+   */
+  async list() {
+    return await this.fetch.get("/api/v1/api-keys");
+  }
+  /**
+   * Get a specific API key by ID
+   *
+   * @param keyId - API key ID
+   * @returns API key details
+   *
+   * @example
+   * ```typescript
+   * const apiKey = await client.management.apiKeys.get('key-uuid')
+   * console.log('Last used:', apiKey.last_used_at)
+   * ```
+   */
+  async get(keyId) {
+    return await this.fetch.get(`/api/v1/api-keys/${keyId}`);
+  }
+  /**
+   * Update an API key
+   *
+   * @param keyId - API key ID
+   * @param updates - Fields to update
+   * @returns Updated API key
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.management.apiKeys.update('key-uuid', {
+   *   name: 'Updated Name',
+   *   rate_limit_per_minute: 200
+   * })
+   * ```
+   */
+  async update(keyId, updates) {
+    return await this.fetch.patch(`/api/v1/api-keys/${keyId}`, updates);
+  }
+  /**
+   * Revoke an API key
+   *
+   * Revoked keys can no longer be used but remain in the system for audit purposes.
+   *
+   * @param keyId - API key ID
+   * @returns Revocation confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.management.apiKeys.revoke('key-uuid')
+   * console.log('API key revoked')
+   * ```
+   */
+  async revoke(keyId) {
+    return await this.fetch.post(`/api/v1/api-keys/${keyId}/revoke`, {});
+  }
+  /**
+   * Delete an API key
+   *
+   * Permanently removes the API key from the system.
+   *
+   * @param keyId - API key ID
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.management.apiKeys.delete('key-uuid')
+   * console.log('API key deleted')
+   * ```
+   */
+  async delete(keyId) {
+    return await this.fetch.delete(`/api/v1/api-keys/${keyId}`);
+  }
+};
+var WebhooksManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Create a new webhook
+   *
+   * @param request - Webhook configuration
+   * @returns Created webhook
+   *
+   * @example
+   * ```typescript
+   * const webhook = await client.management.webhooks.create({
+   *   url: 'https://myapp.com/webhook',
+   *   events: ['user.created', 'user.updated', 'user.deleted'],
+   *   description: 'User events webhook',
+   *   secret: 'my-webhook-secret'
+   * })
+   * ```
+   */
+  async create(request) {
+    return await this.fetch.post("/api/v1/webhooks", request);
+  }
+  /**
+   * List all webhooks for the authenticated user
+   *
+   * @returns List of webhooks
+   *
+   * @example
+   * ```typescript
+   * const { webhooks, total } = await client.management.webhooks.list()
+   *
+   * webhooks.forEach(webhook => {
+   *   console.log(`${webhook.url}: ${webhook.is_active ? 'active' : 'inactive'}`)
+   * })
+   * ```
+   */
+  async list() {
+    return await this.fetch.get("/api/v1/webhooks");
+  }
+  /**
+   * Get a specific webhook by ID
+   *
+   * @param webhookId - Webhook ID
+   * @returns Webhook details
+   *
+   * @example
+   * ```typescript
+   * const webhook = await client.management.webhooks.get('webhook-uuid')
+   * console.log('Events:', webhook.events)
+   * ```
+   */
+  async get(webhookId) {
+    return await this.fetch.get(`/api/v1/webhooks/${webhookId}`);
+  }
+  /**
+   * Update a webhook
+   *
+   * @param webhookId - Webhook ID
+   * @param updates - Fields to update
+   * @returns Updated webhook
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.management.webhooks.update('webhook-uuid', {
+   *   events: ['user.created', 'user.deleted'],
+   *   is_active: false
+   * })
+   * ```
+   */
+  async update(webhookId, updates) {
+    return await this.fetch.patch(`/api/v1/webhooks/${webhookId}`, updates);
+  }
+  /**
+   * Delete a webhook
+   *
+   * @param webhookId - Webhook ID
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.management.webhooks.delete('webhook-uuid')
+   * console.log('Webhook deleted')
+   * ```
+   */
+  async delete(webhookId) {
+    return await this.fetch.delete(`/api/v1/webhooks/${webhookId}`);
+  }
+  /**
+   * Test a webhook by sending a test payload
+   *
+   * @param webhookId - Webhook ID
+   * @returns Test result with status and response
+   *
+   * @example
+   * ```typescript
+   * const result = await client.management.webhooks.test('webhook-uuid')
+   *
+   * if (result.success) {
+   *   console.log('Webhook test successful')
+   * } else {
+   *   console.error('Webhook test failed:', result.error)
+   * }
+   * ```
+   */
+  async test(webhookId) {
+    return await this.fetch.post(`/api/v1/webhooks/${webhookId}/test`, {});
+  }
+  /**
+   * List webhook delivery history
+   *
+   * @param webhookId - Webhook ID
+   * @param limit - Maximum number of deliveries to return (default: 50)
+   * @returns List of webhook deliveries
+   *
+   * @example
+   * ```typescript
+   * const { deliveries } = await client.management.webhooks.listDeliveries('webhook-uuid', 100)
+   *
+   * deliveries.forEach(delivery => {
+   *   console.log(`Event: ${delivery.event}, Status: ${delivery.status_code}`)
+   * })
+   * ```
+   */
+  async listDeliveries(webhookId, limit = 50) {
+    return await this.fetch.get(
+      `/api/v1/webhooks/${webhookId}/deliveries?limit=${limit}`
+    );
+  }
+};
+var InvitationsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Create a new invitation (admin only)
+   *
+   * @param request - Invitation details
+   * @returns Created invitation with invite link
+   *
+   * @example
+   * ```typescript
+   * const invitation = await client.management.invitations.create({
+   *   email: 'newuser@example.com',
+   *   role: 'dashboard_user',
+   *   expiry_duration: 604800 // 7 days in seconds
+   * })
+   *
+   * // Share the invite link
+   * console.log('Send this link to the user:', invitation.invite_link)
+   * ```
+   */
+  async create(request) {
+    return await this.fetch.post("/api/v1/admin/invitations", request);
+  }
+  /**
+   * List all invitations (admin only)
+   *
+   * @param options - Filter options
+   * @returns List of invitations
+   *
+   * @example
+   * ```typescript
+   * // List pending invitations only
+   * const { invitations } = await client.management.invitations.list({
+   *   include_accepted: false,
+   *   include_expired: false
+   * })
+   *
+   * // List all invitations including accepted and expired
+   * const all = await client.management.invitations.list({
+   *   include_accepted: true,
+   *   include_expired: true
+   * })
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.include_accepted !== void 0) {
+      params.append("include_accepted", String(options.include_accepted));
+    }
+    if (options.include_expired !== void 0) {
+      params.append("include_expired", String(options.include_expired));
+    }
+    const queryString = params.toString();
+    const url = queryString ? `/api/v1/admin/invitations?${queryString}` : "/api/v1/admin/invitations";
+    return await this.fetch.get(url);
+  }
+  /**
+   * Validate an invitation token (public endpoint)
+   *
+   * @param token - Invitation token
+   * @returns Validation result with invitation details
+   *
+   * @example
+   * ```typescript
+   * const result = await client.management.invitations.validate('invitation-token')
+   *
+   * if (result.valid) {
+   *   console.log('Valid invitation for:', result.invitation?.email)
+   * } else {
+   *   console.error('Invalid:', result.error)
+   * }
+   * ```
+   */
+  async validate(token) {
+    return await this.fetch.get(`/api/v1/invitations/${token}/validate`);
+  }
+  /**
+   * Accept an invitation and create a new user (public endpoint)
+   *
+   * @param token - Invitation token
+   * @param request - User details (password and name)
+   * @returns Created user with authentication tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await client.management.invitations.accept('invitation-token', {
+   *   password: 'SecurePassword123!',
+   *   name: 'John Doe'
+   * })
+   *
+   * // Store tokens
+   * localStorage.setItem('access_token', response.access_token)
+   * console.log('Welcome:', response.user.name)
+   * ```
+   */
+  async accept(token, request) {
+    return await this.fetch.post(`/api/v1/invitations/${token}/accept`, request);
+  }
+  /**
+   * Revoke an invitation (admin only)
+   *
+   * @param token - Invitation token
+   * @returns Revocation confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.management.invitations.revoke('invitation-token')
+   * console.log('Invitation revoked')
+   * ```
+   */
+  async revoke(token) {
+    return await this.fetch.delete(`/api/v1/admin/invitations/${token}`);
+  }
+};
+var FluxbaseManagement = class {
+  constructor(fetch2) {
+    this.apiKeys = new APIKeysManager(fetch2);
+    this.webhooks = new WebhooksManager(fetch2);
+    this.invitations = new InvitationsManager(fetch2);
+  }
+};
+
+// src/admin.ts
+var FluxbaseAdmin = class {
+  constructor(fetch2) {
+    this.adminToken = null;
+    this.fetch = fetch2;
+    this.settings = new FluxbaseSettings(fetch2);
+    this.ddl = new DDLManager(fetch2);
+    this.oauth = new FluxbaseOAuth(fetch2);
+    this.impersonation = new ImpersonationManager(fetch2);
+    this.management = new FluxbaseManagement(fetch2);
+  }
+  /**
+   * Set admin authentication token
+   */
+  setToken(token) {
+    this.adminToken = token;
+    this.fetch.setAuthToken(token);
+  }
+  /**
+   * Get current admin token
+   */
+  getToken() {
+    return this.adminToken;
+  }
+  /**
+   * Clear admin token
+   */
+  clearToken() {
+    this.adminToken = null;
+    this.fetch.setAuthToken(null);
+  }
+  // ============================================================================
+  // Admin Authentication
+  // ============================================================================
+  /**
+   * Check if initial admin setup is needed
+   *
+   * @returns Setup status indicating if initial setup is required
+   *
+   * @example
+   * ```typescript
+   * const status = await admin.getSetupStatus();
+   * if (status.needs_setup) {
+   *   console.log('Initial setup required');
+   * }
+   * ```
+   */
+  async getSetupStatus() {
+    return await this.fetch.get(
+      "/api/v1/admin/setup/status"
+    );
+  }
+  /**
+   * Perform initial admin setup
+   *
+   * Creates the first admin user and completes initial setup.
+   * This endpoint can only be called once.
+   *
+   * @param email - Admin email address
+   * @param password - Admin password (minimum 12 characters)
+   * @param name - Admin display name
+   * @returns Authentication response with tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.setup({
+   *   email: 'admin@example.com',
+   *   password: 'SecurePassword123!',
+   *   name: 'Admin User'
+   * });
+   *
+   * // Store tokens
+   * localStorage.setItem('admin_token', response.access_token);
+   * ```
+   */
+  async setup(request) {
+    const response = await this.fetch.post(
+      "/api/v1/admin/setup",
+      request
+    );
+    this.setToken(response.access_token);
+    return response;
+  }
+  /**
+   * Admin login
+   *
+   * Authenticate as an admin user
+   *
+   * @param email - Admin email
+   * @param password - Admin password
+   * @returns Authentication response with tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.login({
+   *   email: 'admin@example.com',
+   *   password: 'password123'
+   * });
+   *
+   * // Token is automatically set in the client
+   * console.log('Logged in as:', response.user.email);
+   * ```
+   */
+  async login(request) {
+    const response = await this.fetch.post(
+      "/api/v1/admin/login",
+      request
+    );
+    this.setToken(response.access_token);
+    return response;
+  }
+  /**
+   * Refresh admin access token
+   *
+   * @param refreshToken - Refresh token
+   * @returns New access and refresh tokens
+   *
+   * @example
+   * ```typescript
+   * const refreshToken = localStorage.getItem('admin_refresh_token');
+   * const response = await admin.refreshToken({ refresh_token: refreshToken });
+   *
+   * // Update stored tokens
+   * localStorage.setItem('admin_token', response.access_token);
+   * localStorage.setItem('admin_refresh_token', response.refresh_token);
+   * ```
+   */
+  async refreshToken(request) {
+    const response = await this.fetch.post(
+      "/api/v1/admin/refresh",
+      request
+    );
+    this.setToken(response.access_token);
+    return response;
+  }
+  /**
+   * Admin logout
+   *
+   * Invalidates the current admin session
+   *
+   * @example
+   * ```typescript
+   * await admin.logout();
+   * localStorage.removeItem('admin_token');
+   * ```
+   */
+  async logout() {
+    await this.fetch.post("/api/v1/admin/logout", {});
+    this.clearToken();
+  }
+  /**
+   * Get current admin user information
+   *
+   * @returns Current admin user details
+   *
+   * @example
+   * ```typescript
+   * const { user } = await admin.me();
+   * console.log('Logged in as:', user.email);
+   * console.log('Role:', user.role);
+   * ```
+   */
+  async me() {
+    return await this.fetch.get("/api/v1/admin/me");
+  }
+  // ============================================================================
+  // User Management
+  // ============================================================================
+  /**
+   * List all users
+   *
+   * @param options - Filter and pagination options
+   * @returns List of users with metadata
+   *
+   * @example
+   * ```typescript
+   * // List all users
+   * const { users, total } = await admin.listUsers();
+   *
+   * // List with filters
+   * const result = await admin.listUsers({
+   *   exclude_admins: true,
+   *   search: 'john',
+   *   limit: 50,
+   *   type: 'app'
+   * });
+   * ```
+   */
+  async listUsers(options = {}) {
+    const params = new URLSearchParams();
+    if (options.exclude_admins !== void 0) {
+      params.append("exclude_admins", String(options.exclude_admins));
+    }
+    if (options.search) {
+      params.append("search", options.search);
+    }
+    if (options.limit !== void 0) {
+      params.append("limit", String(options.limit));
+    }
+    if (options.type) {
+      params.append("type", options.type);
+    }
+    const queryString = params.toString();
+    const url = queryString ? `/api/v1/admin/users?${queryString}` : "/api/v1/admin/users";
+    return await this.fetch.get(url);
+  }
+  /**
+   * Get a user by ID
+   *
+   * Fetch a single user's details by their user ID
+   *
+   * @param userId - User ID to fetch
+   * @param type - User type ('app' or 'dashboard')
+   * @returns User details with metadata
+   *
+   * @example
+   * ```typescript
+   * // Get an app user
+   * const user = await admin.getUserById('user-123');
+   *
+   * // Get a dashboard user
+   * const dashboardUser = await admin.getUserById('admin-456', 'dashboard');
+   * console.log('User email:', dashboardUser.email);
+   * console.log('Last login:', dashboardUser.last_login_at);
+   * ```
+   */
+  async getUserById(userId, type = "app") {
+    const url = `/api/v1/admin/users/${userId}?type=${type}`;
+    return await this.fetch.get(url);
+  }
+  /**
+   * Invite a new user
+   *
+   * Creates a new user and optionally sends an invitation email
+   *
+   * @param request - User invitation details
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Created user and invitation details
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.inviteUser({
+   *   email: 'newuser@example.com',
+   *   role: 'user',
+   *   send_email: true
+   * });
+   *
+   * console.log('User invited:', response.user.email);
+   * console.log('Invitation link:', response.invitation_link);
+   * ```
+   */
+  async inviteUser(request, type = "app") {
+    const url = `/api/v1/admin/users/invite?type=${type}`;
+    return await this.fetch.post(url, request);
+  }
+  /**
+   * Delete a user
+   *
+   * Permanently deletes a user and all associated data
+   *
+   * @param userId - User ID to delete
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await admin.deleteUser('user-uuid');
+   * console.log('User deleted');
+   * ```
+   */
+  async deleteUser(userId, type = "app") {
+    const url = `/api/v1/admin/users/${userId}?type=${type}`;
+    return await this.fetch.delete(url);
+  }
+  /**
+   * Update user role
+   *
+   * Changes a user's role
+   *
+   * @param userId - User ID
+   * @param role - New role
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Updated user
+   *
+   * @example
+   * ```typescript
+   * const user = await admin.updateUserRole('user-uuid', 'admin');
+   * console.log('User role updated:', user.role);
+   * ```
+   */
+  async updateUserRole(userId, role, type = "app") {
+    const url = `/api/v1/admin/users/${userId}/role?type=${type}`;
+    return await this.fetch.patch(url, { role });
+  }
+  /**
+   * Reset user password
+   *
+   * Generates a new password for the user and optionally sends it via email
+   *
+   * @param userId - User ID
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Reset confirmation message
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.resetUserPassword('user-uuid');
+   * console.log(response.message);
+   * ```
+   */
+  async resetUserPassword(userId, type = "app") {
+    const url = `/api/v1/admin/users/${userId}/reset-password?type=${type}`;
+    return await this.fetch.post(url, {});
+  }
+};
+
+// src/query-builder.ts
+var QueryBuilder = class {
+  constructor(fetch2, table) {
+    this.selectQuery = "*";
+    this.filters = [];
+    this.orderBys = [];
+    this.singleRow = false;
+    this.fetch = fetch2;
+    this.table = table;
+  }
+  /**
+   * Select columns to return
+   * @example select('*')
+   * @example select('id, name, email')
+   * @example select('id, name, posts(title, content)')
+   */
+  select(columns = "*") {
+    this.selectQuery = columns;
+    return this;
+  }
+  /**
+   * Insert a single row or multiple rows
+   */
+  async insert(data) {
+    const body = Array.isArray(data) ? data : data;
+    const response = await this.fetch.post(`/api/v1/tables/${this.table}`, body);
+    return {
+      data: response,
+      error: null,
+      count: Array.isArray(data) ? data.length : 1,
+      status: 201,
+      statusText: "Created"
+    };
+  }
+  /**
+   * Upsert (insert or update) rows
+   */
+  async upsert(data) {
+    const body = Array.isArray(data) ? data : data;
+    const response = await this.fetch.post(`/api/v1/tables/${this.table}`, body, {
+      headers: {
+        Prefer: "resolution=merge-duplicates"
+      }
+    });
+    return {
+      data: response,
+      error: null,
+      count: Array.isArray(data) ? data.length : 1,
+      status: 201,
+      statusText: "Created"
+    };
+  }
+  /**
+   * Update rows matching the filters
+   */
+  async update(data) {
+    const queryString = this.buildQueryString();
+    const path = `/api/v1/tables/${this.table}${queryString}`;
+    const response = await this.fetch.patch(path, data);
+    return {
+      data: response,
+      error: null,
+      count: null,
+      status: 200,
+      statusText: "OK"
+    };
+  }
+  /**
+   * Delete rows matching the filters
+   */
+  async delete() {
+    const queryString = this.buildQueryString();
+    const path = `/api/v1/tables/${this.table}${queryString}`;
+    await this.fetch.delete(path);
+    return {
+      data: null,
+      error: null,
+      count: null,
+      status: 204,
+      statusText: "No Content"
+    };
+  }
+  /**
+   * Equal to
+   */
+  eq(column, value) {
+    this.filters.push({ column, operator: "eq", value });
+    return this;
+  }
+  /**
+   * Not equal to
+   */
+  neq(column, value) {
+    this.filters.push({ column, operator: "neq", value });
+    return this;
+  }
+  /**
+   * Greater than
+   */
+  gt(column, value) {
+    this.filters.push({ column, operator: "gt", value });
+    return this;
+  }
+  /**
+   * Greater than or equal to
+   */
+  gte(column, value) {
+    this.filters.push({ column, operator: "gte", value });
+    return this;
+  }
+  /**
+   * Less than
+   */
+  lt(column, value) {
+    this.filters.push({ column, operator: "lt", value });
+    return this;
+  }
+  /**
+   * Less than or equal to
+   */
+  lte(column, value) {
+    this.filters.push({ column, operator: "lte", value });
+    return this;
+  }
+  /**
+   * Pattern matching (case-sensitive)
+   */
+  like(column, pattern) {
+    this.filters.push({ column, operator: "like", value: pattern });
+    return this;
+  }
+  /**
+   * Pattern matching (case-insensitive)
+   */
+  ilike(column, pattern) {
+    this.filters.push({ column, operator: "ilike", value: pattern });
+    return this;
+  }
+  /**
+   * Check if value is null or not null
+   */
+  is(column, value) {
+    this.filters.push({ column, operator: "is", value });
+    return this;
+  }
+  /**
+   * Check if value is in array
+   */
+  in(column, values) {
+    this.filters.push({ column, operator: "in", value: values });
+    return this;
+  }
+  /**
+   * Contains (for arrays and JSONB)
+   */
+  contains(column, value) {
+    this.filters.push({ column, operator: "cs", value });
+    return this;
+  }
+  /**
+   * Full-text search
+   */
+  textSearch(column, query) {
+    this.filters.push({ column, operator: "fts", value: query });
+    return this;
+  }
+  /**
+   * Order results
+   */
+  order(column, options) {
+    this.orderBys.push({
+      column,
+      direction: options?.ascending === false ? "desc" : "asc",
+      nulls: options?.nullsFirst ? "first" : "last"
+    });
+    return this;
+  }
+  /**
+   * Limit number of rows returned
+   */
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  /**
+   * Skip rows
+   */
+  offset(count) {
+    this.offsetValue = count;
+    return this;
+  }
+  /**
+   * Return a single row (adds limit(1))
+   */
+  single() {
+    this.singleRow = true;
+    this.limitValue = 1;
+    return this;
+  }
+  /**
+   * Range selection (pagination)
+   */
+  range(from, to) {
+    this.offsetValue = from;
+    this.limitValue = to - from + 1;
+    return this;
+  }
+  /**
+   * Group results by one or more columns (for use with aggregations)
+   *
+   * @param columns - Column name(s) to group by
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Group by single column
+   * const { data } = await client.from('orders')
+   *   .count('*')
+   *   .groupBy('status')
+   *   .execute()
+   *
+   * // Group by multiple columns
+   * const { data } = await client.from('sales')
+   *   .sum('amount')
+   *   .groupBy(['region', 'product_category'])
+   *   .execute()
+   * ```
+   *
+   * @category Aggregation
+   */
+  groupBy(columns) {
+    this.groupByColumns = Array.isArray(columns) ? columns : [columns];
+    return this;
+  }
+  /**
+   * Count rows or a specific column
+   *
+   * @param column - Column to count (default: '*' for row count)
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Count all rows
+   * const { data } = await client.from('users').count().execute()
+   * // Returns: { count: 150 }
+   *
+   * // Count non-null values in a column
+   * const { data } = await client.from('orders').count('completed_at').execute()
+   *
+   * // Count with grouping
+   * const { data } = await client.from('products')
+   *   .count('*')
+   *   .groupBy('category')
+   *   .execute()
+   * // Returns: [{ category: 'electronics', count: 45 }, { category: 'books', count: 23 }]
+   * ```
+   *
+   * @category Aggregation
+   */
+  count(column = "*") {
+    this.selectQuery = `count(${column})`;
+    return this;
+  }
+  /**
+   * Calculate the sum of a numeric column
+   *
+   * @param column - Column to sum
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Sum all prices
+   * const { data } = await client.from('products').sum('price').execute()
+   * // Returns: { sum_price: 15420.50 }
+   *
+   * // Sum by category
+   * const { data } = await client.from('orders')
+   *   .sum('total')
+   *   .groupBy('status')
+   *   .execute()
+   * // Returns: [{ status: 'completed', sum_total: 12500 }, { status: 'pending', sum_total: 3200 }]
+   * ```
+   *
+   * @category Aggregation
+   */
+  sum(column) {
+    this.selectQuery = `sum(${column})`;
+    return this;
+  }
+  /**
+   * Calculate the average of a numeric column
+   *
+   * @param column - Column to average
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Average price
+   * const { data } = await client.from('products').avg('price').execute()
+   * // Returns: { avg_price: 129.99 }
+   *
+   * // Average by category
+   * const { data } = await client.from('products')
+   *   .avg('price')
+   *   .groupBy('category')
+   *   .execute()
+   * ```
+   *
+   * @category Aggregation
+   */
+  avg(column) {
+    this.selectQuery = `avg(${column})`;
+    return this;
+  }
+  /**
+   * Find the minimum value in a column
+   *
+   * @param column - Column to find minimum value
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Find lowest price
+   * const { data } = await client.from('products').min('price').execute()
+   * // Returns: { min_price: 9.99 }
+   *
+   * // Find earliest date
+   * const { data } = await client.from('orders').min('created_at').execute()
+   * ```
+   *
+   * @category Aggregation
+   */
+  min(column) {
+    this.selectQuery = `min(${column})`;
+    return this;
+  }
+  /**
+   * Find the maximum value in a column
+   *
+   * @param column - Column to find maximum value
+   * @returns Query builder for chaining
+   *
+   * @example
+   * ```typescript
+   * // Find highest price
+   * const { data } = await client.from('products').max('price').execute()
+   * // Returns: { max_price: 1999.99 }
+   *
+   * // Find most recent order
+   * const { data } = await client.from('orders').max('created_at').execute()
+   * ```
+   *
+   * @category Aggregation
+   */
+  max(column) {
+    this.selectQuery = `max(${column})`;
+    return this;
+  }
+  /**
+   * Insert multiple rows in a single request (batch insert)
+   *
+   * This is a convenience method that explicitly shows intent for batch operations.
+   * Internally calls `insert()` with an array.
+   *
+   * @param rows - Array of row objects to insert
+   * @returns Promise with the inserted rows
+   *
+   * @example
+   * ```typescript
+   * // Insert multiple users at once
+   * const { data } = await client.from('users').insertMany([
+   *   { name: 'Alice', email: 'alice@example.com' },
+   *   { name: 'Bob', email: 'bob@example.com' },
+   *   { name: 'Charlie', email: 'charlie@example.com' }
+   * ]).execute()
+   * ```
+   *
+   * @category Batch Operations
+   */
+  async insertMany(rows) {
+    return this.insert(rows);
+  }
+  /**
+   * Update multiple rows matching the filters (batch update)
+   *
+   * Updates all rows that match the current query filters.
+   * This is a convenience method that explicitly shows intent for batch operations.
+   *
+   * @param data - Data to update matching rows with
+   * @returns Promise with the updated rows
+   *
+   * @example
+   * ```typescript
+   * // Apply discount to all electronics
+   * const { data } = await client.from('products')
+   *   .eq('category', 'electronics')
+   *   .updateMany({ discount: 10, updated_at: new Date() })
+   *   .execute()
+   *
+   * // Mark all pending orders as processing
+   * const { data } = await client.from('orders')
+   *   .eq('status', 'pending')
+   *   .updateMany({ status: 'processing' })
+   *   .execute()
+   * ```
+   *
+   * @category Batch Operations
+   */
+  async updateMany(data) {
+    return this.update(data);
+  }
+  /**
+   * Delete multiple rows matching the filters (batch delete)
+   *
+   * Deletes all rows that match the current query filters.
+   * This is a convenience method that explicitly shows intent for batch operations.
+   *
+   * @returns Promise confirming deletion
+   *
+   * @example
+   * ```typescript
+   * // Delete all inactive users
+   * await client.from('users')
+   *   .eq('active', false)
+   *   .deleteMany()
+   *   .execute()
+   *
+   * // Delete old logs
+   * await client.from('logs')
+   *   .lt('created_at', '2024-01-01')
+   *   .deleteMany()
+   *   .execute()
+   * ```
+   *
+   * @category Batch Operations
+   */
+  async deleteMany() {
+    return this.delete();
+  }
+  /**
+   * Execute the query and return results
+   */
+  async execute() {
+    const queryString = this.buildQueryString();
+    const path = `/api/v1/tables/${this.table}${queryString}`;
+    try {
+      const data = await this.fetch.get(path);
+      if (this.singleRow) {
+        if (Array.isArray(data) && data.length === 0) {
+          return {
+            data: null,
+            error: { message: "No rows found", code: "PGRST116" },
+            count: 0,
+            status: 404,
+            statusText: "Not Found"
+          };
+        }
+        const singleData = Array.isArray(data) ? data[0] : data;
+        return {
+          data: singleData,
+          error: null,
+          count: 1,
+          status: 200,
+          statusText: "OK"
+        };
+      }
+      return {
+        data,
+        error: null,
+        count: Array.isArray(data) ? data.length : null,
+        status: 200,
+        statusText: "OK"
+      };
+    } catch (err) {
+      const error = err;
+      return {
+        data: null,
+        error: {
+          message: error.message,
+          code: "PGRST000"
+        },
+        count: null,
+        status: 500,
+        statusText: "Internal Server Error"
+      };
+    }
+  }
+  /**
+   * Make QueryBuilder awaitable (implements PromiseLike)
+   * This allows using `await client.from('table').select()` without calling `.execute()`
+   *
+   * @example
+   * ```typescript
+   * // Without .execute() (new way)
+   * const { data } = await client.from('users').select('*')
+   *
+   * // With .execute() (old way, still supported)
+   * const { data } = await client.from('users').select('*').execute()
+   * ```
+   */
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  /**
+   * Build the query string from filters, ordering, etc.
+   */
+  buildQueryString() {
+    const params = new URLSearchParams();
+    if (this.selectQuery && this.selectQuery !== "*") {
+      params.append("select", this.selectQuery);
+    }
+    for (const filter of this.filters) {
+      params.append(filter.column, `${filter.operator}.${this.formatValue(filter.value)}`);
+    }
+    if (this.groupByColumns && this.groupByColumns.length > 0) {
+      params.append("group_by", this.groupByColumns.join(","));
+    }
+    if (this.orderBys.length > 0) {
+      const orderStr = this.orderBys.map((o) => `${o.column}.${o.direction}${o.nulls ? `.nulls${o.nulls}` : ""}`).join(",");
+      params.append("order", orderStr);
+    }
+    if (this.limitValue !== void 0) {
+      params.append("limit", String(this.limitValue));
+    }
+    if (this.offsetValue !== void 0) {
+      params.append("offset", String(this.offsetValue));
+    }
+    const queryString = params.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  /**
+   * Format a value for the query string
+   */
+  formatValue(value) {
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (Array.isArray(value)) {
+      return `(${value.map((v) => this.formatValue(v)).join(",")})`;
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+};
+
+// src/client.ts
+var FluxbaseClient = class {
+  /**
+   * Create a new Fluxbase client instance
+   * @param options - Client configuration options
+   */
+  constructor(options) {
+    this.fetch = new FluxbaseFetch(options.url, {
+      headers: options.headers,
+      timeout: options.timeout,
+      debug: options.debug
+    });
+    this.auth = new FluxbaseAuth(
+      this.fetch,
+      options.auth?.autoRefresh ?? true,
+      options.auth?.persist ?? true
+    );
+    if (options.auth?.token) {
+      this.fetch.setAuthToken(options.auth.token);
+    }
+    this.realtime = new FluxbaseRealtime(options.url, options.auth?.token || null);
+    this.storage = new FluxbaseStorage(this.fetch);
+    this.admin = new FluxbaseAdmin(this.fetch);
+    this.management = new FluxbaseManagement(this.fetch);
+    this.setupAuthSync();
+  }
+  /**
+   * Create a query builder for a database table
+   *
+   * @param table - The table name (can include schema, e.g., 'public.users')
+   * @returns A query builder instance for constructing and executing queries
+   *
+   * @example
+   * ```typescript
+   * // Simple select
+   * const { data } = await client.from('users').select('*').execute()
+   *
+   * // With filters
+   * const { data } = await client.from('products')
+   *   .select('id, name, price')
+   *   .gt('price', 100)
+   *   .eq('category', 'electronics')
+   *   .execute()
+   *
+   * // Insert
+   * await client.from('users').insert({ name: 'John', email: 'john@example.com' }).execute()
+   * ```
+   *
+   * @category Database
+   */
+  from(table) {
+    return new QueryBuilder(this.fetch, table);
+  }
+  /**
+   * Call a PostgreSQL function (Remote Procedure Call)
+   *
+   * @param functionName - The name of the PostgreSQL function to call
+   * @param params - Optional parameters to pass to the function
+   * @returns Promise containing the function result or error
+   *
+   * @example
+   * ```typescript
+   * // Call a function without parameters
+   * const { data, error } = await client.rpc('get_total_users')
+   *
+   * // Call a function with parameters
+   * const { data, error } = await client.rpc('calculate_discount', {
+   *   product_id: 123,
+   *   coupon_code: 'SAVE20'
+   * })
+   * ```
+   *
+   * @category Database
+   */
+  async rpc(functionName, params) {
+    try {
+      const data = await this.fetch.post(`/api/v1/rpc/${functionName}`, params || {});
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Sync auth state with realtime connections
+   * @internal
+   */
+  setupAuthSync() {
+    const originalSetAuthToken = this.fetch.setAuthToken.bind(this.fetch);
+    this.fetch.setAuthToken = (token) => {
+      originalSetAuthToken(token);
+      this.realtime.setToken(token);
+    };
+  }
+  /**
+   * Get the current authentication token
+   *
+   * @returns The current JWT access token, or null if not authenticated
+   *
+   * @category Authentication
+   */
+  getAuthToken() {
+    return this.auth.getAccessToken();
+  }
+  /**
+   * Set a new authentication token
+   *
+   * This updates both the HTTP client and realtime connection with the new token.
+   *
+   * @param token - The JWT access token to set, or null to clear authentication
+   *
+   * @category Authentication
+   */
+  setAuthToken(token) {
+    this.fetch.setAuthToken(token);
+    this.realtime.setToken(token);
+  }
+  /**
+   * Get the internal HTTP client
+   *
+   * Use this for advanced scenarios like making custom API calls or admin operations.
+   *
+   * @returns The internal FluxbaseFetch instance
+   *
+   * @example
+   * ```typescript
+   * // Make a custom API call
+   * const data = await client.http.get('/api/custom-endpoint')
+   * ```
+   *
+   * @category Advanced
+   */
+  get http() {
+    return this.fetch;
+  }
+};
+function createClient(options) {
+  return new FluxbaseClient(options);
+}
+
+exports.APIKeysManager = APIKeysManager;
+exports.AppSettingsManager = AppSettingsManager;
+exports.AuthSettingsManager = AuthSettingsManager;
+exports.DDLManager = DDLManager;
+exports.FluxbaseAdmin = FluxbaseAdmin;
+exports.FluxbaseAuth = FluxbaseAuth;
+exports.FluxbaseClient = FluxbaseClient;
+exports.FluxbaseFetch = FluxbaseFetch;
+exports.FluxbaseManagement = FluxbaseManagement;
+exports.FluxbaseOAuth = FluxbaseOAuth;
+exports.FluxbaseRealtime = FluxbaseRealtime;
+exports.FluxbaseSettings = FluxbaseSettings;
+exports.FluxbaseStorage = FluxbaseStorage;
+exports.ImpersonationManager = ImpersonationManager;
+exports.InvitationsManager = InvitationsManager;
+exports.OAuthProviderManager = OAuthProviderManager;
+exports.QueryBuilder = QueryBuilder;
+exports.RealtimeChannel = RealtimeChannel;
+exports.StorageBucket = StorageBucket;
+exports.SystemSettingsManager = SystemSettingsManager;
+exports.WebhooksManager = WebhooksManager;
+exports.createClient = createClient;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map