@fluxbase/sdk-react 2026.3.1 → 2026.3.2-rc.3

package/dist/index.mjs

@@ -1,1554 +0,0 @@
-// src/context.tsx
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var FluxbaseContext = createContext(null);
-function FluxbaseProvider({ client, children }) {
-  return /* @__PURE__ */ jsx(FluxbaseContext.Provider, { value: client, children });
-}
-function useFluxbaseClient() {
-  const client = useContext(FluxbaseContext);
-  if (!client) {
-    throw new Error("useFluxbaseClient must be used within a FluxbaseProvider");
-  }
-  return client;
-}
-
-// src/use-auth.ts
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-function useUser() {
-  const client = useFluxbaseClient();
-  return useQuery({
-    queryKey: ["fluxbase", "auth", "user"],
-    queryFn: async () => {
-      const { data } = await client.auth.getSession();
-      if (!data?.session) {
-        return null;
-      }
-      try {
-        const result = await client.auth.getCurrentUser();
-        return result.data?.user ?? null;
-      } catch {
-        return null;
-      }
-    },
-    staleTime: 1e3 * 60 * 5
-    // 5 minutes
-  });
-}
-function useSession() {
-  const client = useFluxbaseClient();
-  return useQuery({
-    queryKey: ["fluxbase", "auth", "session"],
-    queryFn: async () => {
-      const { data } = await client.auth.getSession();
-      return data?.session ?? null;
-    },
-    staleTime: 1e3 * 60 * 5
-    // 5 minutes
-  });
-}
-function useSignIn() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (credentials) => {
-      return await client.auth.signIn(credentials);
-    },
-    onSuccess: (session) => {
-      queryClient.setQueryData(["fluxbase", "auth", "session"], session);
-      if (session && "user" in session && session.user) {
-        queryClient.setQueryData(["fluxbase", "auth", "user"], session.user);
-      }
-    }
-  });
-}
-function useSignUp() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (credentials) => {
-      return await client.auth.signUp(credentials);
-    },
-    onSuccess: (response) => {
-      if (response.data) {
-        queryClient.setQueryData(
-          ["fluxbase", "auth", "session"],
-          response.data.session
-        );
-        queryClient.setQueryData(
-          ["fluxbase", "auth", "user"],
-          response.data.user
-        );
-      }
-    }
-  });
-}
-function useSignOut() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async () => {
-      await client.auth.signOut();
-    },
-    onSuccess: () => {
-      queryClient.setQueryData(["fluxbase", "auth", "session"], null);
-      queryClient.setQueryData(["fluxbase", "auth", "user"], null);
-      queryClient.invalidateQueries({ queryKey: ["fluxbase"] });
-    }
-  });
-}
-function useUpdateUser() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (data) => {
-      return await client.auth.updateUser(data);
-    },
-    onSuccess: (user) => {
-      queryClient.setQueryData(["fluxbase", "auth", "user"], user);
-    }
-  });
-}
-function useAuth() {
-  const { data: user, isLoading: isLoadingUser } = useUser();
-  const { data: session, isLoading: isLoadingSession } = useSession();
-  const signIn = useSignIn();
-  const signUp = useSignUp();
-  const signOut = useSignOut();
-  const updateUser = useUpdateUser();
-  return {
-    user,
-    session,
-    isLoading: isLoadingUser || isLoadingSession,
-    isAuthenticated: !!session,
-    signIn: signIn.mutateAsync,
-    signUp: signUp.mutateAsync,
-    signOut: signOut.mutateAsync,
-    updateUser: updateUser.mutateAsync,
-    isSigningIn: signIn.isPending,
-    isSigningUp: signUp.isPending,
-    isSigningOut: signOut.isPending,
-    isUpdating: updateUser.isPending
-  };
-}
-
-// src/use-captcha.ts
-import { useQuery as useQuery2 } from "@tanstack/react-query";
-import { useCallback, useEffect, useRef, useState } from "react";
-function useCaptchaConfig() {
-  const client = useFluxbaseClient();
-  return useQuery2({
-    queryKey: ["fluxbase", "auth", "captcha", "config"],
-    queryFn: async () => {
-      const { data, error } = await client.auth.getCaptchaConfig();
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    staleTime: 1e3 * 60 * 60,
-    // Cache for 1 hour (config rarely changes)
-    gcTime: 1e3 * 60 * 60 * 24
-    // Keep in cache for 24 hours
-  });
-}
-function useCaptcha(provider) {
-  const [token, setToken] = useState(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const executeResolverRef = useRef(null);
-  const executeRejecterRef = useRef(null);
-  const onVerify = useCallback((newToken) => {
-    setToken(newToken);
-    setIsLoading(false);
-    setError(null);
-    setIsReady(true);
-    if (executeResolverRef.current) {
-      executeResolverRef.current(newToken);
-      executeResolverRef.current = null;
-      executeRejecterRef.current = null;
-    }
-  }, []);
-  const onExpire = useCallback(() => {
-    setToken(null);
-    setIsReady(true);
-  }, []);
-  const onError = useCallback((err) => {
-    setError(err);
-    setIsLoading(false);
-    setToken(null);
-    if (executeRejecterRef.current) {
-      executeRejecterRef.current(err);
-      executeResolverRef.current = null;
-      executeRejecterRef.current = null;
-    }
-  }, []);
-  const reset = useCallback(() => {
-    setToken(null);
-    setError(null);
-    setIsLoading(false);
-  }, []);
-  const execute = useCallback(async () => {
-    if (token) {
-      return token;
-    }
-    if (!provider) {
-      return "";
-    }
-    setIsLoading(true);
-    setError(null);
-    return new Promise((resolve, reject) => {
-      executeResolverRef.current = resolve;
-      executeRejecterRef.current = reject;
-    });
-  }, [token, provider]);
-  useEffect(() => {
-    if (provider) {
-      setIsReady(true);
-    }
-  }, [provider]);
-  return {
-    token,
-    isReady,
-    isLoading,
-    error,
-    reset,
-    execute,
-    onVerify,
-    onExpire,
-    onError
-  };
-}
-function isCaptchaRequiredForEndpoint(config, endpoint) {
-  if (!config?.enabled) {
-    return false;
-  }
-  return config.endpoints?.includes(endpoint) ?? false;
-}
-
-// src/use-auth-config.ts
-import { useQuery as useQuery3 } from "@tanstack/react-query";
-function useAuthConfig() {
-  const client = useFluxbaseClient();
-  return useQuery3({
-    queryKey: ["fluxbase", "auth", "config"],
-    queryFn: async () => {
-      const { data, error } = await client.auth.getAuthConfig();
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    staleTime: 1e3 * 60 * 5,
-    // Cache for 5 minutes (config changes infrequently)
-    gcTime: 1e3 * 60 * 60
-    // Keep in cache for 1 hour
-  });
-}
-
-// src/use-saml.ts
-import { useMutation as useMutation2, useQuery as useQuery4, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
-function useSAMLProviders() {
-  const client = useFluxbaseClient();
-  return useQuery4({
-    queryKey: ["fluxbase", "auth", "saml", "providers"],
-    queryFn: async () => {
-      const { data, error } = await client.auth.getSAMLProviders();
-      if (error) throw error;
-      return data.providers;
-    },
-    staleTime: 1e3 * 60 * 5
-    // 5 minutes - providers don't change often
-  });
-}
-function useGetSAMLLoginUrl() {
-  const client = useFluxbaseClient();
-  return useMutation2({
-    mutationFn: async ({
-      provider,
-      options
-    }) => {
-      return await client.auth.getSAMLLoginUrl(provider, options);
-    }
-  });
-}
-function useSignInWithSAML() {
-  const client = useFluxbaseClient();
-  return useMutation2({
-    mutationFn: async ({
-      provider,
-      options
-    }) => {
-      return await client.auth.signInWithSAML(provider, options);
-    }
-  });
-}
-function useHandleSAMLCallback() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient2();
-  return useMutation2({
-    mutationFn: async ({
-      samlResponse,
-      provider
-    }) => {
-      return await client.auth.handleSAMLCallback(samlResponse, provider);
-    },
-    onSuccess: (result) => {
-      if (result.data) {
-        queryClient.setQueryData(
-          ["fluxbase", "auth", "session"],
-          result.data.session
-        );
-        queryClient.setQueryData(
-          ["fluxbase", "auth", "user"],
-          result.data.user
-        );
-        queryClient.invalidateQueries({ queryKey: ["fluxbase"] });
-      }
-    }
-  });
-}
-function useSAMLMetadataUrl() {
-  const client = useFluxbaseClient();
-  return (provider) => {
-    return client.auth.getSAMLMetadataUrl(provider);
-  };
-}
-
-// src/use-graphql.ts
-import { useMutation as useMutation3, useQuery as useQuery5, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
-function useGraphQLQuery(queryKey, query, options) {
-  const client = useFluxbaseClient();
-  const normalizedKey = Array.isArray(queryKey) ? ["fluxbase", "graphql", ...queryKey] : ["fluxbase", "graphql", queryKey];
-  return useQuery5({
-    queryKey: normalizedKey,
-    queryFn: async () => {
-      const response = await client.graphql.execute(
-        query,
-        options?.variables,
-        options?.operationName,
-        options?.requestOptions
-      );
-      if (response.errors && response.errors.length > 0) {
-        throw response.errors[0];
-      }
-      return response.data;
-    },
-    enabled: options?.enabled ?? true,
-    staleTime: options?.staleTime ?? 0,
-    gcTime: options?.gcTime,
-    refetchOnWindowFocus: options?.refetchOnWindowFocus ?? true,
-    select: options?.select
-  });
-}
-function useGraphQLMutation(mutation, options) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient3();
-  return useMutation3({
-    mutationFn: async (variables) => {
-      const response = await client.graphql.execute(
-        mutation,
-        variables,
-        options?.operationName,
-        options?.requestOptions
-      );
-      if (response.errors && response.errors.length > 0) {
-        throw response.errors[0];
-      }
-      return response.data;
-    },
-    onSuccess: (data, variables) => {
-      if (options?.invalidateQueries) {
-        for (const key of options.invalidateQueries) {
-          queryClient.invalidateQueries({
-            queryKey: ["fluxbase", "graphql", key]
-          });
-        }
-      }
-      if (options?.onSuccess && data !== void 0) {
-        options.onSuccess(data, variables);
-      }
-    },
-    onError: (error, variables) => {
-      if (options?.onError) {
-        options.onError(error, variables);
-      }
-    }
-  });
-}
-function useGraphQLIntrospection(options) {
-  const client = useFluxbaseClient();
-  return useQuery5({
-    queryKey: ["fluxbase", "graphql", "__introspection"],
-    queryFn: async () => {
-      const response = await client.graphql.introspect(options?.requestOptions);
-      if (response.errors && response.errors.length > 0) {
-        throw response.errors[0];
-      }
-      return response.data;
-    },
-    enabled: options?.enabled ?? true,
-    staleTime: options?.staleTime ?? 1e3 * 60 * 5
-    // 5 minutes - schema doesn't change often
-  });
-}
-function useGraphQL() {
-  const client = useFluxbaseClient();
-  return {
-    /**
-     * Execute a GraphQL query
-     */
-    executeQuery: (query, variables, options) => {
-      return client.graphql.query(query, variables, options);
-    },
-    /**
-     * Execute a GraphQL mutation
-     */
-    executeMutation: (mutation, variables, options) => {
-      return client.graphql.mutation(mutation, variables, options);
-    },
-    /**
-     * Execute a GraphQL operation with an explicit operation name
-     */
-    execute: (document, variables, operationName, options) => {
-      return client.graphql.execute(document, variables, operationName, options);
-    },
-    /**
-     * Fetch the GraphQL schema via introspection
-     */
-    introspect: (options) => {
-      return client.graphql.introspect(options);
-    }
-  };
-}
-
-// src/use-query.ts
-import { useQuery as useQuery6, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
-function useFluxbaseQuery(buildQuery, options) {
-  const client = useFluxbaseClient();
-  if (!options?.queryKey) {
-    console.warn(
-      "[useFluxbaseQuery] No queryKey provided. This may cause cache misses. Please provide a stable queryKey in options."
-    );
-  }
-  const queryKey = options?.queryKey || ["fluxbase", "query", "unstable"];
-  return useQuery6({
-    queryKey,
-    queryFn: async () => {
-      const query = buildQuery(client);
-      const { data, error } = await query.execute();
-      if (error) {
-        throw error;
-      }
-      return Array.isArray(data) ? data : data ? [data] : [];
-    },
-    ...options
-  });
-}
-function useTable(table, buildQuery, options) {
-  const client = useFluxbaseClient();
-  if (buildQuery && !options?.queryKey) {
-    console.warn(
-      `[useTable] Using buildQuery without a custom queryKey for table "${table}". This may cause cache misses. Provide a queryKey that includes your filter values.`
-    );
-  }
-  return useFluxbaseQuery(
-    (client2) => {
-      const query = client2.from(table);
-      return buildQuery ? buildQuery(query) : query;
-    },
-    {
-      ...options,
-      // Use table name as base key, or custom key if provided
-      queryKey: options?.queryKey || ["fluxbase", "table", table]
-    }
-  );
-}
-function useInsert(table) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation4({
-    mutationFn: async (data) => {
-      const query = client.from(table);
-      const { data: result, error } = await query.insert(data);
-      if (error) {
-        throw error;
-      }
-      return result;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
-    }
-  });
-}
-function useUpdate(table) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation4({
-    mutationFn: async (params) => {
-      const query = client.from(table);
-      const builtQuery = params.buildQuery(query);
-      const { data: result, error } = await builtQuery.update(params.data);
-      if (error) {
-        throw error;
-      }
-      return result;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
-    }
-  });
-}
-function useUpsert(table) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation4({
-    mutationFn: async (data) => {
-      const query = client.from(table);
-      const { data: result, error } = await query.upsert(data);
-      if (error) {
-        throw error;
-      }
-      return result;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
-    }
-  });
-}
-function useDelete(table) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation4({
-    mutationFn: async (buildQuery) => {
-      const query = client.from(table);
-      const builtQuery = buildQuery(query);
-      const { error } = await builtQuery.delete();
-      if (error) {
-        throw error;
-      }
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
-    }
-  });
-}
-
-// src/use-realtime.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
-function useRealtime(options) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient5();
-  const channelRef = useRef2(
-    null
-  );
-  const {
-    channel: channelName,
-    event = "*",
-    callback,
-    autoInvalidate = true,
-    invalidateKey,
-    enabled = true
-  } = options;
-  const callbackRef = useRef2(callback);
-  const invalidateKeyRef = useRef2(invalidateKey);
-  const autoInvalidateRef = useRef2(autoInvalidate);
-  callbackRef.current = callback;
-  invalidateKeyRef.current = invalidateKey;
-  autoInvalidateRef.current = autoInvalidate;
-  useEffect2(() => {
-    if (!enabled) {
-      return;
-    }
-    const channel = client.realtime.channel(channelName);
-    channelRef.current = channel;
-    const handleChange = (payload) => {
-      if (callbackRef.current) {
-        callbackRef.current(payload);
-      }
-      if (autoInvalidateRef.current) {
-        const tableName = channelName.replace(/^table:/, "");
-        const key = invalidateKeyRef.current || ["fluxbase", "table", tableName];
-        queryClient.invalidateQueries({ queryKey: key });
-      }
-    };
-    channel.on(event, handleChange).subscribe();
-    return () => {
-      channel.unsubscribe();
-      channelRef.current = null;
-    };
-  }, [client, channelName, event, queryClient, enabled]);
-  return {
-    channel: channelRef.current
-  };
-}
-function useTableSubscription(table, options) {
-  return useRealtime({
-    ...options,
-    channel: `table:${table}`
-  });
-}
-function useTableInserts(table, callback, options) {
-  return useRealtime({
-    ...options,
-    channel: `table:${table}`,
-    event: "INSERT",
-    callback
-  });
-}
-function useTableUpdates(table, callback, options) {
-  return useRealtime({
-    ...options,
-    channel: `table:${table}`,
-    event: "UPDATE",
-    callback
-  });
-}
-function useTableDeletes(table, callback, options) {
-  return useRealtime({
-    ...options,
-    channel: `table:${table}`,
-    event: "DELETE",
-    callback
-  });
-}
-
-// src/use-storage.ts
-import { useState as useState2 } from "react";
-import {
-  useMutation as useMutation5,
-  useQuery as useQuery7,
-  useQueryClient as useQueryClient6
-} from "@tanstack/react-query";
-function useStorageList(bucket, options) {
-  const client = useFluxbaseClient();
-  const { prefix, limit, offset, ...queryOptions } = options || {};
-  return useQuery7({
-    queryKey: [
-      "fluxbase",
-      "storage",
-      bucket,
-      "list",
-      { prefix, limit, offset }
-    ],
-    queryFn: async () => {
-      const { data, error } = await client.storage.from(bucket).list({ prefix, limit, offset });
-      if (error) {
-        throw error;
-      }
-      return data || [];
-    },
-    ...queryOptions
-  });
-}
-function useStorageUpload(bucket) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (params) => {
-      const { path, file, options } = params;
-      const { data, error } = await client.storage.from(bucket).upload(path, file, options);
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", bucket, "list"]
-      });
-    }
-  });
-}
-function useStorageUploadWithProgress(bucket) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  const [progress, setProgress] = useState2(null);
-  const mutation = useMutation5({
-    mutationFn: async (params) => {
-      const { path, file, options } = params;
-      setProgress({ loaded: 0, total: 0, percentage: 0 });
-      const { data, error } = await client.storage.from(bucket).upload(path, file, {
-        ...options,
-        onUploadProgress: (p) => {
-          setProgress(p);
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", bucket, "list"]
-      });
-    },
-    onError: () => {
-      setProgress(null);
-    }
-  });
-  return {
-    upload: mutation,
-    progress,
-    reset: () => setProgress(null)
-  };
-}
-function useStorageDownload(bucket, path, enabled = true) {
-  const client = useFluxbaseClient();
-  return useQuery7({
-    queryKey: ["fluxbase", "storage", bucket, "download", path],
-    queryFn: async () => {
-      if (!path) {
-        return null;
-      }
-      const { data, error } = await client.storage.from(bucket).download(path);
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    enabled: enabled && !!path
-  });
-}
-function useStorageDelete(bucket) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (paths) => {
-      const { error } = await client.storage.from(bucket).remove(paths);
-      if (error) {
-        throw error;
-      }
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", bucket, "list"]
-      });
-    }
-  });
-}
-function useStoragePublicUrl(bucket, path) {
-  const client = useFluxbaseClient();
-  if (!path) {
-    return null;
-  }
-  const { data } = client.storage.from(bucket).getPublicUrl(path);
-  return data.publicUrl;
-}
-function useStorageTransformUrl(bucket, path, transform) {
-  const client = useFluxbaseClient();
-  if (!path) {
-    return null;
-  }
-  return client.storage.from(bucket).getTransformUrl(path, transform);
-}
-function useStorageSignedUrl(bucket, path, expiresIn) {
-  const client = useFluxbaseClient();
-  return useQuery7({
-    queryKey: ["fluxbase", "storage", bucket, "signed-url", path, expiresIn],
-    queryFn: async () => {
-      if (!path) {
-        return null;
-      }
-      const { data, error } = await client.storage.from(bucket).createSignedUrl(path, { expiresIn });
-      if (error) {
-        throw error;
-      }
-      return data?.signedUrl || null;
-    },
-    enabled: !!path,
-    // Refresh 1 minute before expiry, but ensure staleTime is never negative
-    // For very short expirations (<60s), use half the expiration time
-    staleTime: expiresIn ? Math.max(expiresIn * 500, expiresIn * 1e3 - 6e4) : 1e3 * 60 * 50
-    // 50 minutes default
-  });
-}
-function useStorageSignedUrlWithOptions(bucket, path, options) {
-  const client = useFluxbaseClient();
-  const expiresIn = options?.expiresIn;
-  const transformKey = options?.transform ? JSON.stringify(options.transform) : null;
-  return useQuery7({
-    queryKey: [
-      "fluxbase",
-      "storage",
-      bucket,
-      "signed-url",
-      path,
-      expiresIn,
-      transformKey
-    ],
-    queryFn: async () => {
-      if (!path) {
-        return null;
-      }
-      const { data, error } = await client.storage.from(bucket).createSignedUrl(path, options);
-      if (error) {
-        throw error;
-      }
-      return data?.signedUrl || null;
-    },
-    enabled: !!path,
-    // Refresh 1 minute before expiry, but ensure staleTime is never negative
-    // For very short expirations (<60s), use half the expiration time
-    staleTime: expiresIn ? Math.max(expiresIn * 500, expiresIn * 1e3 - 6e4) : 1e3 * 60 * 50
-    // 50 minutes default
-  });
-}
-function useStorageMove(bucket) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (params) => {
-      const { fromPath, toPath } = params;
-      const { data, error } = await client.storage.from(bucket).move(fromPath, toPath);
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", bucket, "list"]
-      });
-    }
-  });
-}
-function useStorageCopy(bucket) {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (params) => {
-      const { fromPath, toPath } = params;
-      const { data, error } = await client.storage.from(bucket).copy(fromPath, toPath);
-      if (error) {
-        throw error;
-      }
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", bucket, "list"]
-      });
-    }
-  });
-}
-function useStorageBuckets() {
-  const client = useFluxbaseClient();
-  return useQuery7({
-    queryKey: ["fluxbase", "storage", "buckets"],
-    queryFn: async () => {
-      const { data, error } = await client.storage.listBuckets();
-      if (error) {
-        throw error;
-      }
-      return data || [];
-    }
-  });
-}
-function useCreateBucket() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (bucketName) => {
-      const { error } = await client.storage.createBucket(bucketName);
-      if (error) {
-        throw error;
-      }
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", "buckets"]
-      });
-    }
-  });
-}
-function useDeleteBucket() {
-  const client = useFluxbaseClient();
-  const queryClient = useQueryClient6();
-  return useMutation5({
-    mutationFn: async (bucketName) => {
-      const { error } = await client.storage.deleteBucket(bucketName);
-      if (error) {
-        throw error;
-      }
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: ["fluxbase", "storage", "buckets"]
-      });
-    }
-  });
-}
-
-// src/use-admin-auth.ts
-import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2 } from "react";
-function useAdminAuth(options = {}) {
-  const { autoCheck = true } = options;
-  const client = useFluxbaseClient();
-  const [user, setUser] = useState3(null);
-  const [isLoading, setIsLoading] = useState3(autoCheck);
-  const [error, setError] = useState3(null);
-  const checkAuth = useCallback2(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { data, error: apiError } = await client.admin.me();
-      if (apiError) {
-        throw apiError;
-      }
-      setUser(data.user);
-    } catch (err) {
-      setUser(null);
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
-  const login = useCallback2(
-    async (email, password) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const { data, error: apiError } = await client.admin.login({
-          email,
-          password
-        });
-        if (apiError) {
-          throw apiError;
-        }
-        setUser(data.user);
-        return data;
-      } catch (err) {
-        setError(err);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const logout = useCallback2(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      setUser(null);
-    } catch (err) {
-      setError(err);
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  const refresh = useCallback2(async () => {
-    await checkAuth();
-  }, [checkAuth]);
-  useEffect3(() => {
-    if (autoCheck) {
-      checkAuth();
-    }
-  }, [autoCheck, checkAuth]);
-  return {
-    user,
-    isAuthenticated: user !== null,
-    isLoading,
-    error,
-    login,
-    logout,
-    refresh
-  };
-}
-
-// src/use-users.ts
-import { useState as useState4, useEffect as useEffect4, useCallback as useCallback3 } from "react";
-function useUsers(options = {}) {
-  const { autoFetch = true, refetchInterval = 0, ...listOptions } = options;
-  const client = useFluxbaseClient();
-  const [users, setUsers] = useState4([]);
-  const [total, setTotal] = useState4(0);
-  const [isLoading, setIsLoading] = useState4(autoFetch);
-  const [error, setError] = useState4(null);
-  const fetchUsers = useCallback3(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { data, error: apiError } = await client.admin.listUsers(listOptions);
-      if (apiError) {
-        throw apiError;
-      }
-      setUsers(data.users);
-      setTotal(data.total);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, JSON.stringify(listOptions)]);
-  const inviteUser = useCallback3(
-    async (email, role) => {
-      await client.admin.inviteUser({ email, role });
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const updateUserRole = useCallback3(
-    async (userId, role) => {
-      await client.admin.updateUserRole(userId, role);
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const deleteUser = useCallback3(
-    async (userId) => {
-      await client.admin.deleteUser(userId);
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const resetPassword = useCallback3(
-    async (userId) => {
-      const { data, error: error2 } = await client.admin.resetUserPassword(userId);
-      if (error2) {
-        throw error2;
-      }
-      return data;
-    },
-    [client]
-  );
-  useEffect4(() => {
-    if (autoFetch) {
-      fetchUsers();
-    }
-  }, [autoFetch, fetchUsers]);
-  useEffect4(() => {
-    if (refetchInterval > 0) {
-      const interval = setInterval(fetchUsers, refetchInterval);
-      return () => clearInterval(interval);
-    }
-  }, [refetchInterval, fetchUsers]);
-  return {
-    users,
-    total,
-    isLoading,
-    error,
-    refetch: fetchUsers,
-    inviteUser,
-    updateUserRole,
-    deleteUser,
-    resetPassword
-  };
-}
-
-// src/use-client-keys.ts
-import { useState as useState5, useEffect as useEffect5, useCallback as useCallback4 } from "react";
-function useClientKeys(options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [keys, setKeys] = useState5([]);
-  const [isLoading, setIsLoading] = useState5(autoFetch);
-  const [error, setError] = useState5(null);
-  const fetchKeys = useCallback4(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const response = await client.admin.management.clientKeys.list();
-      setKeys(response.client_keys);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
-  const createKey = useCallback4(
-    async (request) => {
-      const response = await client.admin.management.clientKeys.create(request);
-      await fetchKeys();
-      return { key: response.key, keyData: response.client_key };
-    },
-    [client, fetchKeys]
-  );
-  const updateKey = useCallback4(
-    async (keyId, update) => {
-      await client.admin.management.clientKeys.update(keyId, update);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  const revokeKey = useCallback4(
-    async (keyId) => {
-      await client.admin.management.clientKeys.revoke(keyId);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  const deleteKey = useCallback4(
-    async (keyId) => {
-      await client.admin.management.clientKeys.delete(keyId);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  useEffect5(() => {
-    if (autoFetch) {
-      fetchKeys();
-    }
-  }, [autoFetch, fetchKeys]);
-  return {
-    keys,
-    isLoading,
-    error,
-    refetch: fetchKeys,
-    createKey,
-    updateKey,
-    revokeKey,
-    deleteKey
-  };
-}
-var useAPIKeys = useClientKeys;
-
-// src/use-admin-hooks.ts
-import { useState as useState6, useEffect as useEffect6, useCallback as useCallback5 } from "react";
-function useAppSettings(options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [settings, setSettings] = useState6(null);
-  const [isLoading, setIsLoading] = useState6(autoFetch);
-  const [error, setError] = useState6(null);
-  const fetchSettings = useCallback5(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const appSettings = await client.admin.settings.app.get();
-      setSettings(appSettings);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
-  const updateSettings = useCallback5(
-    async (update) => {
-      await client.admin.settings.app.update(update);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  useEffect6(() => {
-    if (autoFetch) {
-      fetchSettings();
-    }
-  }, [autoFetch, fetchSettings]);
-  return {
-    settings,
-    isLoading,
-    error,
-    refetch: fetchSettings,
-    updateSettings
-  };
-}
-function useSystemSettings(options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [settings, setSettings] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(autoFetch);
-  const [error, setError] = useState6(null);
-  const fetchSettings = useCallback5(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const response = await client.admin.settings.system.list();
-      setSettings(response.settings);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
-  const getSetting = useCallback5(
-    (key) => {
-      return settings.find((s) => s.key === key);
-    },
-    [settings]
-  );
-  const updateSetting = useCallback5(
-    async (key, update) => {
-      await client.admin.settings.system.update(key, update);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  const deleteSetting = useCallback5(
-    async (key) => {
-      await client.admin.settings.system.delete(key);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  useEffect6(() => {
-    if (autoFetch) {
-      fetchSettings();
-    }
-  }, [autoFetch, fetchSettings]);
-  return {
-    settings,
-    isLoading,
-    error,
-    refetch: fetchSettings,
-    getSetting,
-    updateSetting,
-    deleteSetting
-  };
-}
-function useWebhooks(options = {}) {
-  const { autoFetch = true, refetchInterval = 0 } = options;
-  const client = useFluxbaseClient();
-  const [webhooks, setWebhooks] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(autoFetch);
-  const [error, setError] = useState6(null);
-  const fetchWebhooks = useCallback5(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const response = await client.admin.management.webhooks.list();
-      setWebhooks(response.webhooks);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
-  const createWebhook = useCallback5(
-    async (webhook) => {
-      const created = await client.admin.management.webhooks.create(webhook);
-      await fetchWebhooks();
-      return created;
-    },
-    [client, fetchWebhooks]
-  );
-  const updateWebhook = useCallback5(
-    async (id, update) => {
-      const updated = await client.admin.management.webhooks.update(id, update);
-      await fetchWebhooks();
-      return updated;
-    },
-    [client, fetchWebhooks]
-  );
-  const deleteWebhook = useCallback5(
-    async (id) => {
-      await client.admin.management.webhooks.delete(id);
-      await fetchWebhooks();
-    },
-    [client, fetchWebhooks]
-  );
-  const testWebhook = useCallback5(
-    async (id) => {
-      await client.admin.management.webhooks.test(id);
-    },
-    [client]
-  );
-  useEffect6(() => {
-    if (autoFetch) {
-      fetchWebhooks();
-    }
-    if (refetchInterval > 0) {
-      const interval = setInterval(fetchWebhooks, refetchInterval);
-      return () => clearInterval(interval);
-    }
-  }, [autoFetch, refetchInterval, fetchWebhooks]);
-  return {
-    webhooks,
-    isLoading,
-    error,
-    refetch: fetchWebhooks,
-    createWebhook,
-    updateWebhook,
-    deleteWebhook,
-    testWebhook
-  };
-}
-
-// src/use-table-export.ts
-import { useState as useState7, useEffect as useEffect7, useCallback as useCallback6 } from "react";
-function useTableDetails(options) {
-  const { schema, table, autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [data, setData] = useState7(null);
-  const [isLoading, setIsLoading] = useState7(autoFetch && !!schema && !!table);
-  const [error, setError] = useState7(null);
-  const fetchData = useCallback6(async () => {
-    if (!schema || !table) return;
-    try {
-      setIsLoading(true);
-      setError(null);
-      const result = await client.admin.ai.getTableDetails(schema, table);
-      if (result.error) {
-        throw result.error;
-      }
-      setData(result.data);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, schema, table]);
-  useEffect7(() => {
-    if (autoFetch && schema && table) {
-      fetchData();
-    }
-  }, [autoFetch, fetchData, schema, table]);
-  return {
-    data,
-    isLoading,
-    error,
-    refetch: fetchData
-  };
-}
-function useExportTable(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const exportTable = useCallback6(
-    async (options) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await client.admin.ai.exportTable(knowledgeBaseId, options);
-        if (result.error) {
-          throw result.error;
-        }
-        return result.data;
-      } catch (err) {
-        setError(err);
-        return null;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, knowledgeBaseId]
-  );
-  const reset = useCallback6(() => {
-    setError(null);
-    setIsLoading(false);
-  }, []);
-  return {
-    exportTable,
-    isLoading,
-    error,
-    reset
-  };
-}
-function useTableExportSyncs(knowledgeBaseId, options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [configs, setConfigs] = useState7([]);
-  const [isLoading, setIsLoading] = useState7(autoFetch);
-  const [error, setError] = useState7(null);
-  const fetchData = useCallback6(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const result = await client.admin.ai.listTableExportSyncs(knowledgeBaseId);
-      if (result.error) {
-        throw result.error;
-      }
-      setConfigs(result.data || []);
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, knowledgeBaseId]);
-  useEffect7(() => {
-    if (autoFetch) {
-      fetchData();
-    }
-  }, [autoFetch, fetchData]);
-  return {
-    configs,
-    isLoading,
-    error,
-    refetch: fetchData
-  };
-}
-function useCreateTableExportSync(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const createSync = useCallback6(
-    async (config) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await client.admin.ai.createTableExportSync(knowledgeBaseId, config);
-        if (result.error) {
-          throw result.error;
-        }
-        return result.data;
-      } catch (err) {
-        setError(err);
-        return null;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, knowledgeBaseId]
-  );
-  return {
-    createSync,
-    isLoading,
-    error
-  };
-}
-function useUpdateTableExportSync(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const updateSync = useCallback6(
-    async (syncId, updates) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await client.admin.ai.updateTableExportSync(knowledgeBaseId, syncId, updates);
-        if (result.error) {
-          throw result.error;
-        }
-        return result.data;
-      } catch (err) {
-        setError(err);
-        return null;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, knowledgeBaseId]
-  );
-  return {
-    updateSync,
-    isLoading,
-    error
-  };
-}
-function useDeleteTableExportSync(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const deleteSync = useCallback6(
-    async (syncId) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await client.admin.ai.deleteTableExportSync(knowledgeBaseId, syncId);
-        if (result.error) {
-          throw result.error;
-        }
-        return true;
-      } catch (err) {
-        setError(err);
-        return false;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, knowledgeBaseId]
-  );
-  return {
-    deleteSync,
-    isLoading,
-    error
-  };
-}
-function useTriggerTableExportSync(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const triggerSync = useCallback6(
-    async (syncId) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await client.admin.ai.triggerTableExportSync(knowledgeBaseId, syncId);
-        if (result.error) {
-          throw result.error;
-        }
-        return result.data;
-      } catch (err) {
-        setError(err);
-        return null;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, knowledgeBaseId]
-  );
-  return {
-    triggerSync,
-    isLoading,
-    error
-  };
-}
-export {
-  FluxbaseProvider,
-  isCaptchaRequiredForEndpoint,
-  useAPIKeys,
-  useAdminAuth,
-  useAppSettings,
-  useAuth,
-  useAuthConfig,
-  useCaptcha,
-  useCaptchaConfig,
-  useClientKeys,
-  useCreateBucket,
-  useCreateTableExportSync,
-  useDelete,
-  useDeleteBucket,
-  useDeleteTableExportSync,
-  useExportTable,
-  useFluxbaseClient,
-  useFluxbaseQuery,
-  useGetSAMLLoginUrl,
-  useGraphQL,
-  useGraphQLIntrospection,
-  useGraphQLMutation,
-  useGraphQLQuery,
-  useHandleSAMLCallback,
-  useInsert,
-  useRealtime,
-  useSAMLMetadataUrl,
-  useSAMLProviders,
-  useSession,
-  useSignIn,
-  useSignInWithSAML,
-  useSignOut,
-  useSignUp,
-  useStorageBuckets,
-  useStorageCopy,
-  useStorageDelete,
-  useStorageDownload,
-  useStorageList,
-  useStorageMove,
-  useStoragePublicUrl,
-  useStorageSignedUrl,
-  useStorageSignedUrlWithOptions,
-  useStorageTransformUrl,
-  useStorageUpload,
-  useStorageUploadWithProgress,
-  useSystemSettings,
-  useTable,
-  useTableDeletes,
-  useTableDetails,
-  useTableExportSyncs,
-  useTableInserts,
-  useTableSubscription,
-  useTableUpdates,
-  useTriggerTableExportSync,
-  useUpdate,
-  useUpdateTableExportSync,
-  useUpdateUser,
-  useUpsert,
-  useUser,
-  useUsers,
-  useWebhooks
-};
-//# sourceMappingURL=index.mjs.map