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

package/dist/index.js

@@ -1,1637 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  FluxbaseProvider: () => FluxbaseProvider,
-  isCaptchaRequiredForEndpoint: () => isCaptchaRequiredForEndpoint,
-  useAPIKeys: () => useAPIKeys,
-  useAdminAuth: () => useAdminAuth,
-  useAppSettings: () => useAppSettings,
-  useAuth: () => useAuth,
-  useAuthConfig: () => useAuthConfig,
-  useCaptcha: () => useCaptcha,
-  useCaptchaConfig: () => useCaptchaConfig,
-  useClientKeys: () => useClientKeys,
-  useCreateBucket: () => useCreateBucket,
-  useCreateTableExportSync: () => useCreateTableExportSync,
-  useDelete: () => useDelete,
-  useDeleteBucket: () => useDeleteBucket,
-  useDeleteTableExportSync: () => useDeleteTableExportSync,
-  useExportTable: () => useExportTable,
-  useFluxbaseClient: () => useFluxbaseClient,
-  useFluxbaseQuery: () => useFluxbaseQuery,
-  useGetSAMLLoginUrl: () => useGetSAMLLoginUrl,
-  useGraphQL: () => useGraphQL,
-  useGraphQLIntrospection: () => useGraphQLIntrospection,
-  useGraphQLMutation: () => useGraphQLMutation,
-  useGraphQLQuery: () => useGraphQLQuery,
-  useHandleSAMLCallback: () => useHandleSAMLCallback,
-  useInsert: () => useInsert,
-  useRealtime: () => useRealtime,
-  useSAMLMetadataUrl: () => useSAMLMetadataUrl,
-  useSAMLProviders: () => useSAMLProviders,
-  useSession: () => useSession,
-  useSignIn: () => useSignIn,
-  useSignInWithSAML: () => useSignInWithSAML,
-  useSignOut: () => useSignOut,
-  useSignUp: () => useSignUp,
-  useStorageBuckets: () => useStorageBuckets,
-  useStorageCopy: () => useStorageCopy,
-  useStorageDelete: () => useStorageDelete,
-  useStorageDownload: () => useStorageDownload,
-  useStorageList: () => useStorageList,
-  useStorageMove: () => useStorageMove,
-  useStoragePublicUrl: () => useStoragePublicUrl,
-  useStorageSignedUrl: () => useStorageSignedUrl,
-  useStorageSignedUrlWithOptions: () => useStorageSignedUrlWithOptions,
-  useStorageTransformUrl: () => useStorageTransformUrl,
-  useStorageUpload: () => useStorageUpload,
-  useStorageUploadWithProgress: () => useStorageUploadWithProgress,
-  useSystemSettings: () => useSystemSettings,
-  useTable: () => useTable,
-  useTableDeletes: () => useTableDeletes,
-  useTableDetails: () => useTableDetails,
-  useTableExportSyncs: () => useTableExportSyncs,
-  useTableInserts: () => useTableInserts,
-  useTableSubscription: () => useTableSubscription,
-  useTableUpdates: () => useTableUpdates,
-  useTriggerTableExportSync: () => useTriggerTableExportSync,
-  useUpdate: () => useUpdate,
-  useUpdateTableExportSync: () => useUpdateTableExportSync,
-  useUpdateUser: () => useUpdateUser,
-  useUpsert: () => useUpsert,
-  useUser: () => useUser,
-  useUsers: () => useUsers,
-  useWebhooks: () => useWebhooks
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/context.tsx
-var import_react = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
-var FluxbaseContext = (0, import_react.createContext)(null);
-function FluxbaseProvider({ client, children }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FluxbaseContext.Provider, { value: client, children });
-}
-function useFluxbaseClient() {
-  const client = (0, import_react.useContext)(FluxbaseContext);
-  if (!client) {
-    throw new Error("useFluxbaseClient must be used within a FluxbaseProvider");
-  }
-  return client;
-}
-
-// src/use-auth.ts
-var import_react_query = require("@tanstack/react-query");
-function useUser() {
-  const client = useFluxbaseClient();
-  return (0, import_react_query.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 (0, import_react_query.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 = (0, import_react_query.useQueryClient)();
-  return (0, import_react_query.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 = (0, import_react_query.useQueryClient)();
-  return (0, import_react_query.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 = (0, import_react_query.useQueryClient)();
-  return (0, import_react_query.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 = (0, import_react_query.useQueryClient)();
-  return (0, import_react_query.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
-var import_react_query2 = require("@tanstack/react-query");
-var import_react2 = require("react");
-function useCaptchaConfig() {
-  const client = useFluxbaseClient();
-  return (0, import_react_query2.useQuery)({
-    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] = (0, import_react2.useState)(null);
-  const [isReady, setIsReady] = (0, import_react2.useState)(false);
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
-  const [error, setError] = (0, import_react2.useState)(null);
-  const executeResolverRef = (0, import_react2.useRef)(null);
-  const executeRejecterRef = (0, import_react2.useRef)(null);
-  const onVerify = (0, import_react2.useCallback)((newToken) => {
-    setToken(newToken);
-    setIsLoading(false);
-    setError(null);
-    setIsReady(true);
-    if (executeResolverRef.current) {
-      executeResolverRef.current(newToken);
-      executeResolverRef.current = null;
-      executeRejecterRef.current = null;
-    }
-  }, []);
-  const onExpire = (0, import_react2.useCallback)(() => {
-    setToken(null);
-    setIsReady(true);
-  }, []);
-  const onError = (0, import_react2.useCallback)((err) => {
-    setError(err);
-    setIsLoading(false);
-    setToken(null);
-    if (executeRejecterRef.current) {
-      executeRejecterRef.current(err);
-      executeResolverRef.current = null;
-      executeRejecterRef.current = null;
-    }
-  }, []);
-  const reset = (0, import_react2.useCallback)(() => {
-    setToken(null);
-    setError(null);
-    setIsLoading(false);
-  }, []);
-  const execute = (0, import_react2.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]);
-  (0, import_react2.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
-var import_react_query3 = require("@tanstack/react-query");
-function useAuthConfig() {
-  const client = useFluxbaseClient();
-  return (0, import_react_query3.useQuery)({
-    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
-var import_react_query4 = require("@tanstack/react-query");
-function useSAMLProviders() {
-  const client = useFluxbaseClient();
-  return (0, import_react_query4.useQuery)({
-    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 (0, import_react_query4.useMutation)({
-    mutationFn: async ({
-      provider,
-      options
-    }) => {
-      return await client.auth.getSAMLLoginUrl(provider, options);
-    }
-  });
-}
-function useSignInWithSAML() {
-  const client = useFluxbaseClient();
-  return (0, import_react_query4.useMutation)({
-    mutationFn: async ({
-      provider,
-      options
-    }) => {
-      return await client.auth.signInWithSAML(provider, options);
-    }
-  });
-}
-function useHandleSAMLCallback() {
-  const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
-    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
-var import_react_query5 = require("@tanstack/react-query");
-function useGraphQLQuery(queryKey, query, options) {
-  const client = useFluxbaseClient();
-  const normalizedKey = Array.isArray(queryKey) ? ["fluxbase", "graphql", ...queryKey] : ["fluxbase", "graphql", queryKey];
-  return (0, import_react_query5.useQuery)({
-    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 = (0, import_react_query5.useQueryClient)();
-  return (0, import_react_query5.useMutation)({
-    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 (0, import_react_query5.useQuery)({
-    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
-var import_react_query6 = require("@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 (0, import_react_query6.useQuery)({
-    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 = (0, import_react_query6.useQueryClient)();
-  return (0, import_react_query6.useMutation)({
-    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 = (0, import_react_query6.useQueryClient)();
-  return (0, import_react_query6.useMutation)({
-    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 = (0, import_react_query6.useQueryClient)();
-  return (0, import_react_query6.useMutation)({
-    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 = (0, import_react_query6.useQueryClient)();
-  return (0, import_react_query6.useMutation)({
-    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
-var import_react3 = require("react");
-var import_react_query7 = require("@tanstack/react-query");
-function useRealtime(options) {
-  const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query7.useQueryClient)();
-  const channelRef = (0, import_react3.useRef)(
-    null
-  );
-  const {
-    channel: channelName,
-    event = "*",
-    callback,
-    autoInvalidate = true,
-    invalidateKey,
-    enabled = true
-  } = options;
-  const callbackRef = (0, import_react3.useRef)(callback);
-  const invalidateKeyRef = (0, import_react3.useRef)(invalidateKey);
-  const autoInvalidateRef = (0, import_react3.useRef)(autoInvalidate);
-  callbackRef.current = callback;
-  invalidateKeyRef.current = invalidateKey;
-  autoInvalidateRef.current = autoInvalidate;
-  (0, import_react3.useEffect)(() => {
-    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
-var import_react4 = require("react");
-var import_react_query8 = require("@tanstack/react-query");
-function useStorageList(bucket, options) {
-  const client = useFluxbaseClient();
-  const { prefix, limit, offset, ...queryOptions } = options || {};
-  return (0, import_react_query8.useQuery)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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 = (0, import_react_query8.useQueryClient)();
-  const [progress, setProgress] = (0, import_react4.useState)(null);
-  const mutation = (0, import_react_query8.useMutation)({
-    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 (0, import_react_query8.useQuery)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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 (0, import_react_query8.useQuery)({
-    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 (0, import_react_query8.useQuery)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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 (0, import_react_query8.useQuery)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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 = (0, import_react_query8.useQueryClient)();
-  return (0, import_react_query8.useMutation)({
-    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
-var import_react5 = require("react");
-function useAdminAuth(options = {}) {
-  const { autoCheck = true } = options;
-  const client = useFluxbaseClient();
-  const [user, setUser] = (0, import_react5.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react5.useState)(autoCheck);
-  const [error, setError] = (0, import_react5.useState)(null);
-  const checkAuth = (0, import_react5.useCallback)(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 = (0, import_react5.useCallback)(
-    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 = (0, import_react5.useCallback)(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      setUser(null);
-    } catch (err) {
-      setError(err);
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  const refresh = (0, import_react5.useCallback)(async () => {
-    await checkAuth();
-  }, [checkAuth]);
-  (0, import_react5.useEffect)(() => {
-    if (autoCheck) {
-      checkAuth();
-    }
-  }, [autoCheck, checkAuth]);
-  return {
-    user,
-    isAuthenticated: user !== null,
-    isLoading,
-    error,
-    login,
-    logout,
-    refresh
-  };
-}
-
-// src/use-users.ts
-var import_react6 = require("react");
-function useUsers(options = {}) {
-  const { autoFetch = true, refetchInterval = 0, ...listOptions } = options;
-  const client = useFluxbaseClient();
-  const [users, setUsers] = (0, import_react6.useState)([]);
-  const [total, setTotal] = (0, import_react6.useState)(0);
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(autoFetch);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const fetchUsers = (0, import_react6.useCallback)(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 = (0, import_react6.useCallback)(
-    async (email, role) => {
-      await client.admin.inviteUser({ email, role });
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const updateUserRole = (0, import_react6.useCallback)(
-    async (userId, role) => {
-      await client.admin.updateUserRole(userId, role);
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const deleteUser = (0, import_react6.useCallback)(
-    async (userId) => {
-      await client.admin.deleteUser(userId);
-      await fetchUsers();
-    },
-    [client, fetchUsers]
-  );
-  const resetPassword = (0, import_react6.useCallback)(
-    async (userId) => {
-      const { data, error: error2 } = await client.admin.resetUserPassword(userId);
-      if (error2) {
-        throw error2;
-      }
-      return data;
-    },
-    [client]
-  );
-  (0, import_react6.useEffect)(() => {
-    if (autoFetch) {
-      fetchUsers();
-    }
-  }, [autoFetch, fetchUsers]);
-  (0, import_react6.useEffect)(() => {
-    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
-var import_react7 = require("react");
-function useClientKeys(options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [keys, setKeys] = (0, import_react7.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react7.useState)(autoFetch);
-  const [error, setError] = (0, import_react7.useState)(null);
-  const fetchKeys = (0, import_react7.useCallback)(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 = (0, import_react7.useCallback)(
-    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 = (0, import_react7.useCallback)(
-    async (keyId, update) => {
-      await client.admin.management.clientKeys.update(keyId, update);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  const revokeKey = (0, import_react7.useCallback)(
-    async (keyId) => {
-      await client.admin.management.clientKeys.revoke(keyId);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  const deleteKey = (0, import_react7.useCallback)(
-    async (keyId) => {
-      await client.admin.management.clientKeys.delete(keyId);
-      await fetchKeys();
-    },
-    [client, fetchKeys]
-  );
-  (0, import_react7.useEffect)(() => {
-    if (autoFetch) {
-      fetchKeys();
-    }
-  }, [autoFetch, fetchKeys]);
-  return {
-    keys,
-    isLoading,
-    error,
-    refetch: fetchKeys,
-    createKey,
-    updateKey,
-    revokeKey,
-    deleteKey
-  };
-}
-var useAPIKeys = useClientKeys;
-
-// src/use-admin-hooks.ts
-var import_react8 = require("react");
-function useAppSettings(options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [settings, setSettings] = (0, import_react8.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const fetchSettings = (0, import_react8.useCallback)(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 = (0, import_react8.useCallback)(
-    async (update) => {
-      await client.admin.settings.app.update(update);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  (0, import_react8.useEffect)(() => {
-    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] = (0, import_react8.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const fetchSettings = (0, import_react8.useCallback)(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 = (0, import_react8.useCallback)(
-    (key) => {
-      return settings.find((s) => s.key === key);
-    },
-    [settings]
-  );
-  const updateSetting = (0, import_react8.useCallback)(
-    async (key, update) => {
-      await client.admin.settings.system.update(key, update);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  const deleteSetting = (0, import_react8.useCallback)(
-    async (key) => {
-      await client.admin.settings.system.delete(key);
-      await fetchSettings();
-    },
-    [client, fetchSettings]
-  );
-  (0, import_react8.useEffect)(() => {
-    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] = (0, import_react8.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const fetchWebhooks = (0, import_react8.useCallback)(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 = (0, import_react8.useCallback)(
-    async (webhook) => {
-      const created = await client.admin.management.webhooks.create(webhook);
-      await fetchWebhooks();
-      return created;
-    },
-    [client, fetchWebhooks]
-  );
-  const updateWebhook = (0, import_react8.useCallback)(
-    async (id, update) => {
-      const updated = await client.admin.management.webhooks.update(id, update);
-      await fetchWebhooks();
-      return updated;
-    },
-    [client, fetchWebhooks]
-  );
-  const deleteWebhook = (0, import_react8.useCallback)(
-    async (id) => {
-      await client.admin.management.webhooks.delete(id);
-      await fetchWebhooks();
-    },
-    [client, fetchWebhooks]
-  );
-  const testWebhook = (0, import_react8.useCallback)(
-    async (id) => {
-      await client.admin.management.webhooks.test(id);
-    },
-    [client]
-  );
-  (0, import_react8.useEffect)(() => {
-    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
-var import_react9 = require("react");
-function useTableDetails(options) {
-  const { schema, table, autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [data, setData] = (0, import_react9.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(autoFetch && !!schema && !!table);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const fetchData = (0, import_react9.useCallback)(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]);
-  (0, import_react9.useEffect)(() => {
-    if (autoFetch && schema && table) {
-      fetchData();
-    }
-  }, [autoFetch, fetchData, schema, table]);
-  return {
-    data,
-    isLoading,
-    error,
-    refetch: fetchData
-  };
-}
-function useExportTable(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const exportTable = (0, import_react9.useCallback)(
-    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 = (0, import_react9.useCallback)(() => {
-    setError(null);
-    setIsLoading(false);
-  }, []);
-  return {
-    exportTable,
-    isLoading,
-    error,
-    reset
-  };
-}
-function useTableExportSyncs(knowledgeBaseId, options = {}) {
-  const { autoFetch = true } = options;
-  const client = useFluxbaseClient();
-  const [configs, setConfigs] = (0, import_react9.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(autoFetch);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const fetchData = (0, import_react9.useCallback)(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]);
-  (0, import_react9.useEffect)(() => {
-    if (autoFetch) {
-      fetchData();
-    }
-  }, [autoFetch, fetchData]);
-  return {
-    configs,
-    isLoading,
-    error,
-    refetch: fetchData
-  };
-}
-function useCreateTableExportSync(knowledgeBaseId) {
-  const client = useFluxbaseClient();
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const createSync = (0, import_react9.useCallback)(
-    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] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const updateSync = (0, import_react9.useCallback)(
-    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] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const deleteSync = (0, import_react9.useCallback)(
-    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] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const triggerSync = (0, import_react9.useCallback)(
-    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
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  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.js.map