fastapi-rtk 0.2.16 → 0.2.17

package/dist/core/esm/fab-react-toolkit-patch/api/hooks/useProvideApi.mjs

@@ -1,303 +1,29 @@
-import { useState, useRef, useEffect, useMemo, useCallback } from "react";
-import { getItemId, urlJoin } from "fastapi-rtk/utils";
-import { useDidUpdate, useSetState } from "@mantine/hooks";
-import { keepPreviousData } from "../../../../../.external/esm/@tanstack_query-core@5.83.1/@tanstack/query-core/build/modern/utils.mjs";
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.84.0_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
-import { createItem } from "../utils/api/createItem.mjs";
-import { deleteItem } from "../utils/api/deleteItem.mjs";
+import { createItem } from "../../../Wrappers/ApiProvider/utils/api/createItem.mjs";
+import { deleteItem } from "../../../Wrappers/ApiProvider/utils/api/deleteItem.mjs";
+import { getInfo } from "../../../Wrappers/ApiProvider/utils/api/getInfo.mjs";
+import { getItem } from "../../../Wrappers/ApiProvider/utils/api/getItem.mjs";
+import { updateItem } from "../../../Wrappers/ApiProvider/utils/api/updateItem.mjs";
+import { uploadItems } from "../../../Wrappers/ApiProvider/utils/api/uploadItems.mjs";
 import { downloadItems } from "../utils/api/downloadItems.mjs";
-import { getInfo } from "../utils/api/getInfo.mjs";
-import { getItem } from "../utils/api/getItem.mjs";
 import { getItems } from "../utils/api/getItems.mjs";
-import { updateItem } from "../utils/api/updateItem.mjs";
-import { uploadItems } from "../utils/api/uploadItems.mjs";
-import { convertId } from "../utils/convertId.mjs";
-import { convertInfo } from "../utils/convertInfo.mjs";
-import { createQueryParams } from "../utils/createQueryParams.mjs";
-function useFabProvideApi({
-  path,
-  initialQueryParams,
-  relation,
-  fetchInfo = true,
-  clearInfoOnRefetch = false,
-  clearDataOnRefetch = false,
-  resetQueryParamsOnPathChange = true,
-  infoQueryProps,
-  dataQueryProps,
-  throwOnError = false,
-  streaming: streamingMode = false
-}) {
-  const [queryParams, setQueryParams] = useState(
-    initialQueryParams ? createQueryParams(null, initialQueryParams) : null
-  );
-  const pathRef = useRef(path);
-  useEffect(() => {
-    pathRef.current = path;
-  }, [path]);
-  const memoizedQueryParamsPathRef = useRef(path);
-  const memoizedQueryParams = useMemo(
-    () => {
-      memoizedQueryParamsPathRef.current = path;
-      return queryParams ? {
-        ...queryParams,
-        ...relation ? {
-          filters: [
-            ...queryParams.filters || [],
-            { col: relation.foreign_key, opr: relation.type, value: convertId(getItemId(relation)) }
-          ]
-        } : {}
-      } : null;
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [queryParams, relation]
-  );
-  const queryParamsRef = useRef(memoizedQueryParams);
-  useEffect(() => {
-    queryParamsRef.current = memoizedQueryParams;
-  }, [memoizedQueryParams]);
-  const setQueryParamsCallback = useCallback(
-    (partialQueryParams) => setQueryParams((prev) => {
-      if (typeof partialQueryParams === "function") {
-        partialQueryParams = partialQueryParams(prev);
-      }
-      if (!prev) {
-        return createQueryParams(null, partialQueryParams);
-      }
-      const newQueryParams = createQueryParams({ ...prev }, partialQueryParams);
-      if (partialQueryParams) {
-        if ((partialQueryParams.filters || partialQueryParams.order_column || partialQueryParams.order_direction) && !partialQueryParams.page) {
-          newQueryParams.page = 0;
-        }
-        if (streamingMode) {
-          if (partialQueryParams.page && partialQueryParams.page !== prev.page && !partialQueryParams.streaming) {
-            throw new Error("You cannot change page in streaming mode, use streaming.fetch() instead");
-          }
-          if (partialQueryParams.page_size && partialQueryParams.page_size !== prev.page_size) {
-            throw new Error("You cannot change page size in streaming mode, use streaming.fetch() instead");
-          }
-        }
-      }
-      return newQueryParams;
-    }),
-    [streamingMode]
-  );
-  const [error, setError] = useState();
-  const memoizedError = useMemo(() => error, [error]);
-  const resetError = useCallback(() => setError(void 0), []);
-  const {
-    data: info,
-    isFetching: infoLoading,
-    refetch: infoRefetch,
-    error: infoError
-  } = useQuery({
-    queryKey: [`info`, path],
-    queryFn: ({ signal }) => getInfo(urlJoin(path, "_info"), signal).then((data2) => ({ ...convertInfo(data2), path })),
-    placeholderData: clearInfoOnRefetch ? null : keepPreviousData,
-    enabled: fetchInfo,
-    retry: false,
-    refetchOnMount: false,
-    refetchOnReconnect: false,
-    refetchOnWindowFocus: false,
-    ...infoQueryProps
-  });
-  const {
-    data,
-    isFetching: dataLoading,
-    refetch: dataRefetch,
-    error: dataError
-  } = useQuery({
-    queryKey: [`data`, memoizedQueryParamsPathRef.current, JSON.stringify(memoizedQueryParams)],
-    queryFn: ({ signal }) => memoizedQueryParams ? getItems(urlJoin(memoizedQueryParamsPathRef.current, "/"), memoizedQueryParams, signal).then((data2) => ({
-      ...data2,
-      result: data2.result.map((item, index) => ({ ...item, id: data2.ids[index] })),
-      path: memoizedQueryParamsPathRef.current,
-      queryParams: memoizedQueryParams
-    })) : null,
-    placeholderData: clearDataOnRefetch ? null : keepPreviousData,
-    retry: false,
-    ...dataQueryProps
-  });
-  useEffect(() => {
-    if (infoError) {
-      setError({ message: `Couldn't fetch info`, originalError: infoError });
-      return;
-    }
-    if (dataError) {
-      setError({ message: `Couldn't fetch list`, originalError: dataError });
-      return;
-    }
-    resetError();
-  }, [infoError, dataError, resetError]);
-  const loading = useMemo(() => infoLoading || dataLoading, [infoLoading, dataLoading]);
-  useDidUpdate(() => {
-    if (!resetQueryParamsOnPathChange) {
-      return;
-    }
-    const newQueryParams = createQueryParams(null, initialQueryParams);
-    if (queryParams == null ? void 0 : queryParams.page_size) {
-      newQueryParams.page_size = queryParams.page_size;
-    }
-    setQueryParams({ ...newQueryParams });
-  }, [path]);
-  const getEntry = useCallback(
-    async (id) => {
-      try {
-        resetError();
-        const response = await getItem(pathRef.current, convertId(id));
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't fetch item with id ${id}`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const addEntry = useCallback(
-    async (item) => {
-      try {
-        resetError();
-        const response = await createItem(pathRef.current, item);
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't add item`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const updateEntry = useCallback(
-    async (id, item) => {
-      try {
-        resetError();
-        const response = await updateItem(pathRef.current, convertId(id), item);
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't update item with id ${id}`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const deleteEntry = useCallback(
-    async (id) => {
-      try {
-        resetError();
-        const response = await deleteItem(pathRef.current, convertId(id));
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't delete item with id ${id}`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const download = useCallback(
-    async (label, { export_mode, delimiter, quotechar } = {}) => {
-      try {
-        resetError();
-        await downloadItems(pathRef.current, queryParamsRef.current, { label, export_mode, delimiter, quotechar });
-      } catch (error2) {
-        setError({ message: `Couldn't download`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const upload = useCallback(
-    async (file, { delimiter, quotechar } = {}) => {
-      try {
-        resetError();
-        const response = await uploadItems(pathRef.current, file, { delimiter, quotechar });
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't upload`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [resetError, throwOnError]
-  );
-  const [streaming, setStreaming] = useSetState({
-    data: {},
-    isEnd: false,
-    fetch: streamingMode ? () => setQueryParamsCallback({ page: 0, streaming: true }) : () => null
-  });
-  useEffect(() => {
-    if (!streamingMode) {
-      return;
-    }
-    if (!data) {
-      return;
-    }
-    setStreaming((prev) => {
-      var _a;
-      const newStreaming = { isEnd: false };
-      const currentPage = Object.keys(prev.data).length;
-      const nextPage = ((_a = data.queryParams) == null ? void 0 : _a.page) ?? 0;
-      if (nextPage < currentPage) {
-        newStreaming.data = {};
-      } else {
-        newStreaming.data = { ...prev.data };
-      }
-      newStreaming.data[nextPage] = data.result;
-      if (data.result.length < data.queryParams.page_size) {
-        newStreaming.isEnd = true;
-        newStreaming.fetch = () => null;
-      } else {
-        newStreaming.fetch = () => setQueryParamsCallback({ page: nextPage + 1, streaming: true });
-      }
-      return newStreaming;
-    });
-  }, [data, setQueryParamsCallback, setStreaming, streamingMode]);
-  const specialKey = useMemo(() => {
-    var _a;
-    const specialKey2 = {
-      all: "all",
-      actions: "actions"
-    };
-    (_a = data == null ? void 0 : data.list_columns) == null ? void 0 : _a.forEach((key) => {
-      if (specialKey2[key]) {
-        specialKey2[key] = `_${key}`;
-      }
-    });
-    return specialKey2;
-  }, [data == null ? void 0 : data.list_columns]);
-  const refetch = useCallback(
-    () => queryParamsRef.current ? dataRefetch() : setQueryParamsCallback(),
-    [dataRefetch, setQueryParamsCallback]
-  );
-  return {
-    path,
-    data,
-    info,
-    queryParams: memoizedQueryParams,
-    loading,
-    error: memoizedError,
-    streaming,
-    specialKey,
-    setQueryParams: setQueryParamsCallback,
-    refetch,
-    refetchInfo: infoRefetch,
-    getEntry,
-    addEntry,
-    updateEntry,
-    deleteEntry,
-    download,
-    upload,
-    resetError
-  };
-}
+const defaultApi = {
+  getItem,
+  getItems,
+  createItem,
+  updateItem,
+  deleteItem,
+  downloadItems,
+  uploadItems,
+  getInfo,
+  // eslint-disable-next-line no-unused-vars
+  formCreateItem: async (path, item) => {
+    throw new Error("formCreateItem is not implemented in fab");
+  },
+  // eslint-disable-next-line no-unused-vars
+  formUpdateItem: async (path, id, item) => {
+    throw new Error("formUpdateItem is not implemented in fab");
+  }
+};
 export {
-  useFabProvideApi
+  defaultApi
 };

package/dist/core/esm/fab-react-toolkit-patch/api/hooks/useProvideBulk.mjs

@@ -1,27 +1,5 @@
-import { useState, useCallback, useMemo } from "react";
-import { postBulk } from "../utils/bulkActions/postBulkAction.mjs";
-const useFabProvideBulk = ({ path }) => {
-  const [selectedIds, setSelectedIds] = useState([]);
-  const [error, setError] = useState();
-  const resetError = useCallback(() => setError(void 0), []);
-  const dispatchBulkActions = useCallback(
-    async (handler, data) => {
-      try {
-        resetError();
-        if (data === void 0) {
-          data = selectedIds;
-        }
-        const response = await postBulk(path, handler, data);
-        return response;
-      } catch (error2) {
-        setError({ message: `Couldn't perform bulk action`, originalError: error2 });
-      }
-    },
-    [path, resetError, selectedIds]
-  );
-  const bulkActions = useMemo(() => ({ selectedIds, setSelectedIds }), [selectedIds, setSelectedIds]);
-  return { bulkActions, dispatchBulkActions, error, resetError };
-};
+import { postBulk } from "../../../Wrappers/ApiProvider/utils/bulkActions/postBulkAction.mjs";
+const defaultBulk = { postBulk };
 export {
-  useFabProvideBulk
+  defaultBulk
 };

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/getItems.mjs

@@ -1,5 +1,4 @@
-import { createFetchParams } from "fastapi-rtk/utils";
-import { parseResponse } from "./utils/parseResponse.mjs";
+import { createFetchParams, parseResponse } from "fastapi-rtk/utils";
 const getItems = async (path, queryParams, signal) => {
   const { fetchPath, options } = createFetchParams({ path, method: "GET", queryParams: { q: queryParams } });
   const response = await fetch(fetchPath, { signal, ...options });

package/dist/core/esm/fab-react-toolkit-patch/auth/hooks/useProvideAuth.mjs

@@ -1,60 +1,13 @@
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.84.0_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
-import { useQueryClient } from "../../../../../.external/esm/@tanstack_react-query@5.84.0_react@18.3.1/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
-import { useState, useCallback } from "react";
-import { authSignin, authSignout, authResetPassword, authOAuthSignin } from "../utils/authFetch.mjs";
-import { getUser, updateUser } from "../utils/userCRUD.mjs";
-function useFabProvideAuth(baseURL, authQueryProps) {
-  const queryClient = useQueryClient();
-  const query = useQuery({
-    queryKey: ["user"],
-    queryFn: ({ signal }) => getUser(baseURL, signal),
-    retry: false,
-    ...authQueryProps
-  });
-  const [error, setError] = useState();
-  const resetError = useCallback(() => setError(void 0), []);
-  const signin = useCallback(
-    ({ username, password }) => {
-      resetError();
-      authSignin(baseURL, { username, password }).then(() => queryClient.invalidateQueries({ queryKey: ["user"] })).catch((err) => setError(err));
-    },
-    [baseURL, queryClient, resetError]
-  );
-  const signout = useCallback(() => {
-    resetError();
-    authSignout(baseURL).then(() => queryClient.resetQueries({ queryKey: ["user"] })).then(() => queryClient.resetQueries({ queryKey: ["info"] })).catch((err) => setError(err));
-  }, [baseURL, queryClient, resetError]);
-  const update = useCallback(
-    (data) => {
-      resetError();
-      updateUser(baseURL, data).then(() => queryClient.invalidateQueries({ queryKey: ["user"] })).catch((err) => setError(err));
-    },
-    [baseURL, queryClient, resetError]
-  );
-  const resetPassword = useCallback(
-    (password) => {
-      resetError();
-      authResetPassword(baseURL, password, query.data).catch((err) => setError(err));
-    },
-    [baseURL, query.data, resetError]
-  );
-  const oauth_signin = useCallback(
-    (provider, popup) => authOAuthSignin(baseURL, provider, popup, () => queryClient.invalidateQueries({ queryKey: ["user"] })),
-    [baseURL, queryClient]
-  );
-  return {
-    user: query.isError ? null : query.data,
-    loading: query.isFetching,
-    error: error ? error.message : null,
-    signin,
-    signout,
-    update,
-    resetPassword,
-    oauth_signin,
-    refetch: query.refetch,
-    resetError
-  };
-}
+import { authOAuthSignin, authResetPassword, authSignout, authSignin } from "../utils/authFetch.mjs";
+import { updateUser, getUser } from "../utils/userCRUD.mjs";
+const defaultAuth = {
+  getUser,
+  update: updateUser,
+  signin: authSignin,
+  signout: authSignout,
+  resetPassword: authResetPassword,
+  oauthSignin: authOAuthSignin
+};
 export {
-  useFabProvideAuth
+  defaultAuth
 };

package/dist/core/esm/fab-react-toolkit-patch/auth/hooks/useProvideInfo.mjs

@@ -1,19 +1,5 @@
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.84.0_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
-import { useEffect } from "react";
 import { authInfo } from "../utils/authFetch.mjs";
-function useFabProvideInfo(baseUrl, auth) {
-  const query = useQuery({
-    queryKey: ["info"],
-    queryFn: ({ signal }) => authInfo(baseUrl, signal),
-    enabled: false
-  });
-  useEffect(() => {
-    if (auth.user && !query.data) {
-      query.refetch();
-    }
-  }, [auth.user, query]);
-  return { baseUrl, info: query.data, loading: query.isFetching, error: query.error, fab: true };
-}
+const defaultInfo = { getInfo: authInfo };
 export {
-  useFabProvideInfo
+  defaultInfo
 };

package/dist/core/esm/fab-react-toolkit-patch/auth/utils/authFetch.mjs

@@ -46,7 +46,7 @@ async function authResetPassword(baseUrl, newPassword, { email }) {
     throw new Error("Couldn't reset password");
   }
 }
-async function authOAuthSignin(baseUrl, provider, popup, afterSigninPopup) {
+function authOAuthSignin(baseUrl, provider, popup, afterSigninPopup) {
   const url = urlJoin(baseUrl, "auth/login", provider);
   if (!popup) {
     window.location.href = urlJoin(baseUrl, "auth/login", provider);

package/dist/core/lib/Wrappers/ApiProvider/ApiProvider.d.ts

@@ -1,3 +1,18 @@
+/**
+ * @typedef {Object} ApiProviderProps
+ * @property {string} [resource_name] - The name of the resource to be used in the API path
+ * @property {Record<string, any>} [initialQueryParams] - The initial query parameters to be used in the API requests
+ * @property {string} [relation] - The relation to be used in the API requests
+ * @property {boolean} [fetchInfo] - Whether to fetch the `info` for the API requests when the component mounts
+ * @property {boolean} [clearInfoOnRefetch] - Whether to clear the `info` on refetch
+ * @property {boolean} [clearDataOnRefetch] - Whether to clear the `data` on refetch
+ * @property {boolean} [resetQueryParamsOnPathChange] - Whether to reset the `queryParams` on path change
+ * @property {Record<string, any>} [infoQueryProps] - The react-query props for the info query
+ * @property {Record<string, any>} [dataQueryProps] - The react-query props for the data query
+ * @property {boolean} [throwOnError] - Whether to throw an error on API request failure
+ * @property {boolean} [streaming] - Whether to enable streaming for the API requests
+ * @property {ReactNode} children - The children to be rendered inside the provider
+ */
 /**
  * ApiProvider component that wraps the application and provides the API context, bulk actions context, and form contexts.
  * @param {ApiProviderProps} props

package/dist/core/lib/Wrappers/ApiProvider/hooks/useProvideApi.d.ts

@@ -10,6 +10,17 @@ export function useProvideApi({ path, initialQueryParams, relation, fetchInfo, c
     dataQueryProps: any;
     throwOnError?: boolean;
     streaming?: boolean;
+}, api?: {
+    getItem: (path: any, id: any) => Promise<string | Record<string, any>>;
+    getItems: (path: string, queryParams: Record<string, any>, signal: AbortSignal) => Promise<Record<string, any> | string>;
+    createItem: (path: any, data: any) => Promise<string | Record<string, any>>;
+    updateItem: (path: any, id: any, data: any) => Promise<string | Record<string, any>>;
+    deleteItem: (path: any, id: any) => Promise<string | Record<string, any>>;
+    downloadItems: (path: any, queryParams: any, { label, export_mode, delimiter, quotechar }?: {}) => Promise<void>;
+    uploadItems: (path: any, file: any, { delimiter, quotechar }?: {}) => Promise<string | Record<string, any>>;
+    getInfo: (path: string, signal: AbortSignal) => Promise<Record<string, any>>;
+    formCreateItem: (path: any, data: any) => Promise<string | Record<string, any>>;
+    formUpdateItem: (path: any, id: any, data: any) => Promise<string | Record<string, any>>;
 }): {
     path: any;
     data: unknown;

package/dist/core/lib/Wrappers/ApiProvider/hooks/useProvideBulk.d.ts

@@ -1,11 +1,17 @@
+import { postBulk } from '../utils/bulkActions/postBulkAction';
+export namespace defaultBulk {
+    export { postBulk };
+}
 export function useProvideBulk({ path }: {
     path: any;
+}, bulk?: {
+    postBulk: (path: any, handler: any, data: any) => Promise<string | Record<string, any>>;
 }): {
     bulkActions: {
         selectedIds: any[];
         setSelectedIds: import('react').Dispatch<import('react').SetStateAction<any[]>>;
     };
-    dispatchBulkActions: (handler: any, data: any) => Promise<any>;
+    dispatchBulkActions: (handler: any, data: any) => Promise<string | Record<string, any>>;
     error: undefined;
     resetError: () => void;
 };

package/dist/core/lib/Wrappers/ApiProvider/utils/bulkActions/postBulkAction.d.ts

@@ -1 +1 @@
-export function postBulk(path: any, handler: any, data: any): Promise<any>;
+export function postBulk(path: any, handler: any, data: any): Promise<string | Record<string, any>>;

package/dist/core/lib/Wrappers/Provider/hooks/useProvideAuth.d.ts

@@ -1,15 +1,25 @@
-export function useProvideAuth(baseURL: any, authQueryProps: any): {
+import { getUser, updateUser } from '../utils/userCRUD';
+import { authSignin, authSignout, authResetPassword, authOAuthSignin } from '../utils/authFetch';
+export function useProvideAuth(baseURL: any, authQueryProps: any, auth?: {
+    getUser: typeof getUser;
+    update: typeof updateUser;
+    signin: typeof authSignin;
+    signout: typeof authSignout;
+    resetPassword: typeof authResetPassword;
+    oauthSignin: typeof authOAuthSignin;
+}): {
     user: unknown;
     loading: boolean;
     error: any;
     signin: ({ username, password }: {
         username: any;
         password: any;
-    }) => void;
-    signout: () => void;
-    update: (data: any) => void;
-    resetPassword: (password: any) => void;
-    oauth_signin: (provider: any, popup: any) => Promise<void>;
+    }) => Promise<void>;
+    signout: () => Promise<void>;
+    update: (data: any) => Promise<void>;
+    resetPassword: (password: any) => Promise<void>;
+    oauthSignin: (provider: any, popup: any) => void;
     refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<unknown, Error>>;
     resetError: () => void;
+    oauth_signin: (provider: any, popup: any) => void;
 };

package/dist/core/lib/Wrappers/Provider/hooks/useProvideInfo.d.ts

@@ -1,4 +1,7 @@
-export function useProvideInfo(baseUrl: any, auth: any): {
+import { authInfo } from '../utils/authFetch';
+export function useProvideInfo(baseUrl: any, auth: any, info?: {
+    getInfo: typeof authInfo;
+}): {
     baseUrl: any;
     info: Record<string, any>;
     loading: boolean;

package/dist/core/lib/Wrappers/Provider/utils/authFetch.d.ts

@@ -38,10 +38,9 @@ export function authResetPassword(baseUrl: string, newPassword: string, { email
  * @param {string} provider - The OAuth provider to use for sign-in (e.g., 'google', 'facebook').
  * @param {boolean} popup - Whether to use a popup window for the sign-in process.
  * @param {function} [afterSigninPopup] - Optional callback function to be called after the popup is closed.
- *
- * @returns {Promise<void>} A promise that resolves when the sign-in process is initiated.
+ * @returns {void} Redirects the user to the OAuth provider's sign-in page or opens a popup window for the sign-in process.
  */
-export function authOAuthSignin(baseUrl: string, provider: string, popup: boolean, afterSigninPopup?: Function): Promise<void>;
+export function authOAuthSignin(baseUrl: string, provider: string, popup: boolean, afterSigninPopup?: Function): void;
 /**
  * Fetches authentication information for the user.
  *

package/dist/core/lib/fab-react-toolkit-patch/api/hooks/useProvideApi.d.ts

@@ -1,41 +1,20 @@
-export function useFabProvideApi({ path, initialQueryParams, relation, fetchInfo, clearInfoOnRefetch, clearDataOnRefetch, resetQueryParamsOnPathChange, infoQueryProps, dataQueryProps, throwOnError, streaming: streamingMode, }: {
-    path: any;
-    initialQueryParams: any;
-    relation: any;
-    fetchInfo?: boolean;
-    clearInfoOnRefetch?: boolean;
-    clearDataOnRefetch?: boolean;
-    resetQueryParamsOnPathChange?: boolean;
-    infoQueryProps: any;
-    dataQueryProps: any;
-    throwOnError?: boolean;
-    streaming?: boolean;
-}): {
-    path: any;
-    data: unknown;
-    info: unknown;
-    queryParams: {
-        filters?: any[];
-    };
-    loading: boolean;
-    error: undefined;
-    streaming: {
-        data: {};
-        isEnd: boolean;
-        fetch: () => void;
-    };
-    specialKey: {
-        all: string;
-        actions: string;
-    };
-    setQueryParams: (partialQueryParams: any) => void;
-    refetch: () => void | Promise<import('@tanstack/react-query').QueryObserverResult<unknown, Error>>;
-    refetchInfo: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<unknown, Error>>;
-    getEntry: (id: any) => Promise<string | Record<string, any>>;
-    addEntry: (item: any) => Promise<string | Record<string, any>>;
-    updateEntry: (id: any, item: any) => Promise<string | Record<string, any>>;
-    deleteEntry: (id: any) => Promise<string | Record<string, any>>;
-    download: (label: any, { export_mode, delimiter, quotechar }?: {}) => Promise<void>;
-    upload: (file: any, { delimiter, quotechar }?: {}) => Promise<string | Record<string, any>>;
-    resetError: () => void;
-};
+import { getItem } from '../../../Wrappers/ApiProvider/utils/api/getItem';
+import { getItems } from '../utils/api/getItems';
+import { createItem } from '../../../Wrappers/ApiProvider/utils/api/createItem';
+import { updateItem } from '../../../Wrappers/ApiProvider/utils/api/updateItem';
+import { deleteItem } from '../../../Wrappers/ApiProvider/utils/api/deleteItem';
+import { downloadItems } from '../utils/api/downloadItems';
+import { uploadItems } from '../../../Wrappers/ApiProvider/utils/api/uploadItems';
+import { getInfo } from '../../../Wrappers/ApiProvider/utils/api/getInfo';
+export namespace defaultApi {
+    export { getItem };
+    export { getItems };
+    export { createItem };
+    export { updateItem };
+    export { deleteItem };
+    export { downloadItems };
+    export { uploadItems };
+    export { getInfo };
+    export function formCreateItem(path: any, item: any): Promise<never>;
+    export function formUpdateItem(path: any, id: any, item: any): Promise<never>;
+}