fastapi-rtk 2.8.0 → 2.9.1

package/dist/api/esm/auth/authFetch.mjs

@@ -0,0 +1,63 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "../fetchers/request.mjs";
+async function authSignin(adapters, baseUrl, credentials) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth", adapters.authTransport.loginPath), method: "POST" },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, {
+    ...options,
+    headers: { ...options.headers, "Content-Type": "application/x-www-form-urlencoded" },
+    body: adapters.authTransport.buildLoginBody(credentials)
+  });
+  if (!res.ok) {
+    if (res.status === 400) {
+      throw new Error("Username or password wrong.");
+    } else {
+      throw new Error("Failed to sign in.");
+    }
+  }
+  await adapters.authTransport.persistLogin(res);
+}
+async function authSignout(adapters, baseUrl) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/logout"), method: "POST" },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, options);
+  if (!res.ok) {
+    throw new Error("Failed to sign out.");
+  }
+  await adapters.authTransport.clearLogin();
+}
+async function authResetPassword(adapters, baseUrl, newPassword, { email }) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/forgot-password"), method: "POST", body: { email } },
+    adapters
+  );
+  const forgotPasswordRes = await adapters.network.request(fetchPath, options);
+  const { token } = await parseResponse(forgotPasswordRes);
+  const { fetchPath: fetchPath2, options: options2 } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/reset-password"), method: "POST", body: { token, password: newPassword } },
+    adapters
+  );
+  const resetPasswordRes = await adapters.network.request(fetchPath2, options2);
+  await parseResponse(resetPasswordRes);
+}
+async function authOAuthSignin(adapters, baseUrl, provider, popup, afterSigninPopup) {
+  const url = urlJoin(baseUrl, "auth/login", provider);
+  await adapters.oauthOpener.open(url, { popup, onClose: afterSigninPopup });
+}
+async function authInfo(adapters, baseUrl, signal) {
+  const { fetchPath, options } = await buildRequest({ path: urlJoin(baseUrl, "info/"), method: "GET" }, adapters);
+  const res = await adapters.network.request(fetchPath, { signal, ...options });
+  return await parseResponse(res);
+}
+export {
+  authInfo,
+  authOAuthSignin,
+  authResetPassword,
+  authSignin,
+  authSignout
+};

package/dist/api/esm/auth/userCRUD.mjs

@@ -0,0 +1,20 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "../fetchers/request.mjs";
+async function getUser(adapters, baseUrl, signal) {
+  const { fetchPath, options } = await buildRequest({ path: urlJoin(baseUrl, "auth/user"), method: "GET" }, adapters);
+  const res = await adapters.network.request(fetchPath, { signal, ...options });
+  return await parseResponse(res);
+}
+async function updateUser(adapters, baseUrl, userData) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/user"), method: "PUT", body: userData },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, options);
+  return await parseResponse(res);
+}
+export {
+  getUser,
+  updateUser
+};

package/dist/api/esm/fetchers/createItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const createItem = async (adapters, path, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/"), method: "POST", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  createItem
+};

package/dist/api/esm/fetchers/deleteItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const deleteItem = async (adapters, path, id, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "DELETE", options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  deleteItem
+};

package/dist/api/esm/fetchers/downloadItems.mjs

@@ -0,0 +1,33 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const downloadItems = async (adapters, path, queryParams, { label, export_mode, delimiter, quotechar } = {}) => {
+  const _queryParams = { ...queryParams, check_validity: true };
+  if (label) {
+    _queryParams.label = label;
+  }
+  if (export_mode) {
+    _queryParams.export_mode = export_mode;
+  }
+  if (delimiter) {
+    _queryParams.delimiter = delimiter;
+  }
+  if (quotechar) {
+    _queryParams.quotechar = quotechar;
+  }
+  const { fetchPath: fetchPatchCheck, options: optionsCheck } = await buildRequest(
+    { path: urlJoin(path, "/download"), method: "GET", queryParams: _queryParams },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPatchCheck, optionsCheck);
+  await parseResponse(response);
+  delete _queryParams.check_validity;
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(path, "/download"), method: "GET", queryParams: _queryParams },
+    adapters
+  );
+  await adapters.fileDownload.save({ url: fetchPath, filename: label, headers: options.headers });
+};
+export {
+  downloadItems
+};

package/dist/api/esm/fetchers/formCreateItem.mjs

@@ -0,0 +1,18 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { convertToFormData } from "../utils/convertToFormData/convertToFormData.mjs";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const formCreateItem = async (adapters, path, data, options) => {
+  const formData = convertToFormData(data, adapters.formData);
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/"), method: "POST", options },
+    adapters
+  );
+  delete fetchOptions["headers"]["Content-Type"];
+  fetchOptions["body"] = formData;
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  formCreateItem
+};

package/dist/api/esm/fetchers/formUpdateItem.mjs

@@ -0,0 +1,18 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { convertToFormData } from "../utils/convertToFormData/convertToFormData.mjs";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const formUpdateItem = async (adapters, path, id, data, options) => {
+  const formData = convertToFormData(data, adapters.formData);
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "PUT", options },
+    adapters
+  );
+  delete fetchOptions["headers"]["Content-Type"];
+  fetchOptions["body"] = formData;
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  formUpdateItem
+};

package/dist/api/esm/fetchers/getInfo.mjs

@@ -0,0 +1,10 @@
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getInfo = async (adapters, path, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest({ path, method: "GET", options }, adapters);
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getInfo
+};

package/dist/api/esm/fetchers/getItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getItem = async (adapters, path, id, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "GET", options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getItem
+};

package/dist/api/esm/fetchers/getItems.mjs

@@ -0,0 +1,13 @@
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getItems = async (adapters, path, queryParams, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path, method: "GET", queryParams, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getItems
+};

package/dist/api/esm/fetchers/postBulkAction.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const postBulk = async (adapters, path, handler, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/bulk", handler), method: "POST", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  postBulk
+};

package/dist/api/esm/fetchers/request.mjs

@@ -0,0 +1,9 @@
+import { createFetchParams } from "../utils/createFetchParams/createFetchParams.mjs";
+const buildRequest = async (args, adapters) => {
+  const { fetchPath, options } = createFetchParams(args);
+  const decorated = await adapters.authTransport.decorateRequest(options);
+  return { fetchPath, options: decorated };
+};
+export {
+  buildRequest
+};

package/dist/api/esm/fetchers/updateItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const updateItem = async (adapters, path, id, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "PUT", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  updateItem
+};

package/dist/api/esm/fetchers/uploadItems.mjs

@@ -0,0 +1,24 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const uploadItems = async (adapters, path, file, { delimiter, quotechar } = {}) => {
+  const formData = new FormData();
+  adapters.formData.appendFile(formData, "file", file);
+  const queryParams = {};
+  if (delimiter) {
+    queryParams.delimiter = delimiter;
+  }
+  if (quotechar) {
+    queryParams.quotechar = quotechar;
+  }
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(path, "/upload"), method: "POST", queryParams },
+    adapters
+  );
+  delete options.headers["Content-Type"];
+  const response = await adapters.network.request(fetchPath, { ...options, body: formData });
+  return await parseResponse(response);
+};
+export {
+  uploadItems
+};

package/dist/{core → api}/esm/hooks/auth/useAuth.mjs

@@ -1,4 +1,4 @@
-import { useAuthProvider } from "../../Wrappers/Provider/Contexts/AuthContext.mjs";
+import { useAuthProvider } from "../../Provider/Contexts/AuthContext.mjs";
 const useAuth = (options) => (
   // #MUSTASSERT the AuthContext is created from an untyped createSafeContext, so the provider hook returns unknown
   useAuthProvider(options)

package/dist/{core → api}/esm/hooks/auth/useInfo.mjs

@@ -1,4 +1,4 @@
-import { useInfoProvider } from "../../Wrappers/Provider/Contexts/InfoContext.mjs";
+import { useInfoProvider } from "../../Provider/Contexts/InfoContext.mjs";
 const useInfo = (options) => (
   // #MUSTASSERT the InfoContext is created from an untyped createSafeContext, so the provider hook returns unknown
   useInfoProvider(options)

package/dist/api/esm/hooks/useDidUpdate.mjs

@@ -0,0 +1,20 @@
+import { useRef, useEffect } from "react";
+const useDidUpdate = (fn, dependencies) => {
+  const mounted = useRef(false);
+  useEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  useEffect(() => {
+    if (mounted.current) {
+      return fn();
+    }
+    mounted.current = true;
+    return void 0;
+  }, dependencies);
+};
+export {
+  useDidUpdate
+};

package/dist/api/esm/index.mjs

@@ -0,0 +1,77 @@
+import { AdaptersProvider, useAdapters, useAdaptersProvider } from "./adapters/AdaptersContext.mjs";
+import { authInfo, authOAuthSignin, authResetPassword, authSignin, authSignout } from "./auth/authFetch.mjs";
+import { getUser, updateUser } from "./auth/userCRUD.mjs";
+import { convertToFormData } from "./utils/convertToFormData/convertToFormData.mjs";
+import { createFetchParams } from "./utils/createFetchParams/createFetchParams.mjs";
+import { parseResponse } from "./utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./fetchers/request.mjs";
+import { getItems } from "./fetchers/getItems.mjs";
+import { getItem } from "./fetchers/getItem.mjs";
+import { createItem } from "./fetchers/createItem.mjs";
+import { updateItem } from "./fetchers/updateItem.mjs";
+import { deleteItem } from "./fetchers/deleteItem.mjs";
+import { getInfo } from "./fetchers/getInfo.mjs";
+import { formCreateItem } from "./fetchers/formCreateItem.mjs";
+import { formUpdateItem } from "./fetchers/formUpdateItem.mjs";
+import { uploadItems } from "./fetchers/uploadItems.mjs";
+import { downloadItems } from "./fetchers/downloadItems.mjs";
+import { postBulk } from "./fetchers/postBulkAction.mjs";
+import { Provider, withProvider } from "./Provider/Provider.mjs";
+import { AuthContextProvider, useAuthProvider } from "./Provider/Contexts/AuthContext.mjs";
+import { InfoContextProvider, useInfoProvider } from "./Provider/Contexts/InfoContext.mjs";
+import { ApiProvider, withApiProvider } from "./ApiProvider/ApiProvider.mjs";
+import { BulkActionsContextProvider, useBulkActionsProvider } from "./ApiProvider/Contexts/BulkActionsContext.mjs";
+import { FormContextAddProvider, FormContextDeleteProvider, FormContextEditProvider, FormContextViewProvider, useFormAddProvider, useFormDeleteProvider, useFormEditProvider, useFormViewProvider } from "./ApiProvider/Contexts/FormContext.mjs";
+import { useAuth } from "./hooks/auth/useAuth.mjs";
+import { useInfo } from "./hooks/auth/useInfo.mjs";
+import { useDidUpdate } from "./hooks/useDidUpdate.mjs";
+import * as index from "../../.external/esm/@tanstack_react-query@5.90.20_react@19.2.3/@tanstack/react-query/build/modern/index.mjs";
+export {
+  AdaptersProvider,
+  ApiProvider,
+  AuthContextProvider,
+  BulkActionsContextProvider,
+  FormContextAddProvider,
+  FormContextDeleteProvider,
+  FormContextEditProvider,
+  FormContextViewProvider,
+  InfoContextProvider,
+  Provider,
+  authInfo,
+  authOAuthSignin,
+  authResetPassword,
+  authSignin,
+  authSignout,
+  buildRequest,
+  convertToFormData,
+  createFetchParams,
+  createItem,
+  deleteItem,
+  downloadItems,
+  formCreateItem,
+  formUpdateItem,
+  getInfo,
+  getItem,
+  getItems,
+  getUser,
+  parseResponse,
+  postBulk,
+  index as rq,
+  updateItem,
+  updateUser,
+  uploadItems,
+  useAdapters,
+  useAdaptersProvider,
+  useAuth,
+  useAuthProvider,
+  useBulkActionsProvider,
+  useDidUpdate,
+  useFormAddProvider,
+  useFormDeleteProvider,
+  useFormEditProvider,
+  useFormViewProvider,
+  useInfo,
+  useInfoProvider,
+  withApiProvider,
+  withProvider
+};

package/dist/{utils/esm → api/esm/utils}/convertToFormData/convertToFormData.mjs

@@ -1,4 +1,4 @@
-const convertToFormData = (data) => {
+const convertToFormData = (data, formDataAdapter) => {
   const formData = new FormData();
   Object.entries(data).forEach(([key, value]) => {
     if (value === void 0) {
@@ -9,17 +9,17 @@ const convertToFormData = (data) => {
         formData.append(key, null);
         return;
       }
-      const files = value.filter((item) => item instanceof File);
-      const stringValues = value.filter((item) => !(item instanceof File));
+      const files = value.filter((item) => formDataAdapter.isFilePart(item));
+      const stringValues = value.filter((item) => !formDataAdapter.isFilePart(item));
       files.forEach((file) => {
-        formData.append(key, file);
+        formDataAdapter.appendFile(formData, key, file);
       });
       stringValues.forEach((file) => {
         formData.append(key, file);
       });
       return;
     }
-    if (value && typeof value === "object" && !(value instanceof File)) {
+    if (value && typeof value === "object" && !formDataAdapter.isFilePart(value)) {
       formData.append(key, JSON.stringify(value));
       return;
     }

package/dist/{utils/esm → api/esm/utils}/createFetchParams/createFetchParams.mjs

@@ -1,4 +1,3 @@
-import { createSearchParams } from "react-router";
 function createFetchParams(args) {
   const { method, body, queryParams, options: userOptions } = args;
   let path = args.path;
@@ -9,7 +8,7 @@ function createFetchParams(args) {
     acc[key] = String(value);
     return acc;
   }, {});
-  const searchParams = createSearchParams(data);
+  const searchParams = new URLSearchParams(data);
   if (searchParams.size > 0) {
     path = path + "?" + searchParams;
   }
@@ -17,7 +16,6 @@ function createFetchParams(args) {
     // #MUSTANNOTATE string literals like 'include' widen to string without the annotation; indexed-access type constrains them
     method,
     mode: "cors",
-    credentials: "include",
     redirect: "follow",
     referrerPolicy: "no-referrer",
     body: body ? JSON.stringify(body) : null,

package/dist/api/lib/ApiProvider/ApiProvider.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from 'react';
+import { ApiProviderProps, WithApiProviderOptions } from './types';
+/**
+ * Provides the API context, bulk actions context, and form contexts to its children.
+ */
+export declare function ApiProvider<TQuery extends object = object>(props: ApiProviderProps<TQuery>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Higher-order component to wrap a component with ApiProvider.
+ *
+ * @param apiProviderProps - The props to be passed to the ApiProvider or a function that returns them.
+ * @param Component - The component to be wrapped.
+ * @param options - Additional options for the HOC.
+ * @returns The wrapped component.
+ */
+export declare const withApiProvider: <P extends object>(apiProviderProps: ApiProviderProps | ((props: P) => ApiProviderProps), Component: ComponentType<P>, options?: WithApiProviderOptions) => ComponentType<P> & {
+    displayName?: string;
+};

package/dist/{core/lib/Wrappers → api/lib}/ApiProvider/Contexts/BulkActionsContext.d.ts

@@ -1,2 +1,2 @@
-import { BulkActionsContextValue } from '../../../hooks/api/types';
+import { BulkActionsContextValue } from '../hooks/types';
 export declare const BulkActionsContextProvider: import('react').Provider<BulkActionsContextValue | null>, useBulkActionsProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<BulkActionsContextValue>) => BulkActionsContextValue;

package/dist/api/lib/ApiProvider/Contexts/FormContext.d.ts

@@ -0,0 +1,5 @@
+import { FormsContextValue } from '../hooks/types';
+export declare const FormContextViewProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormViewProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextAddProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormAddProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextEditProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormEditProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextDeleteProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormDeleteProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;

package/dist/api/lib/ApiProvider/hooks/types.d.ts

@@ -0,0 +1,150 @@
+import { convertId } from 'fastapi-rtk/utils';
+import { EntryRow } from 'fastapi-rtk/contexts';
+import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseQueryOptions, UseQueryResult } from '../../../../.external/lib/@tanstack/react-query';
+import { RefObject } from 'react';
+import { Adapters } from '../../adapters/types';
+import { createItem } from '../../fetchers/createItem';
+import { deleteItem } from '../../fetchers/deleteItem';
+import { downloadItems } from '../../fetchers/downloadItems';
+import { formCreateItem } from '../../fetchers/formCreateItem';
+import { formUpdateItem } from '../../fetchers/formUpdateItem';
+import { getInfo } from '../../fetchers/getInfo';
+import { getItem } from '../../fetchers/getItem';
+import { getItems } from '../../fetchers/getItems';
+import { updateItem } from '../../fetchers/updateItem';
+import { uploadItems } from '../../fetchers/uploadItems';
+import { postBulk } from '../../fetchers/postBulkAction';
+import { BulkActionResponse } from '../../fetchers/bulkActions.types';
+import { DataPage, PrimaryKey, StreamingPage, ValidationError } from 'fastapi-rtk/api-types';
+import { CoreConvertedInfo, QueryParams } from '../utils/types';
+export type { DataPage, StreamingPage };
+/** An entry identifier as accepted by the action functions before conversion. */
+export type EntryId = Parameters<typeof convertId>[0];
+/** The converted `/_info` data as held by the info query, tagged with the resource path. */
+export type InfoQueryData = CoreConvertedInfo & {
+    path: string;
+};
+/** The set of API functions the provider hooks dispatch through. */
+export interface ApiFunctions {
+    getItem: typeof getItem;
+    getItems: typeof getItems;
+    createItem: typeof createItem;
+    updateItem: typeof updateItem;
+    deleteItem: typeof deleteItem;
+    downloadItems: typeof downloadItems;
+    uploadItems: typeof uploadItems;
+    getInfo: typeof getInfo;
+    formCreateItem: typeof formCreateItem;
+    formUpdateItem: typeof formUpdateItem;
+}
+/** The set of bulk-action functions the bulk provider dispatches through. */
+export interface BulkFunctions {
+    postBulk: typeof postBulk;
+}
+/** A relation reference seeded into the query filters by the provider. */
+export interface RelationParam {
+    foreign_key?: string;
+    type?: string;
+    id?: PrimaryKey | null;
+    id_?: PrimaryKey | null;
+}
+/** The arguments accepted by `useApiActions`. */
+export interface UseApiActionsParams {
+    api: ApiFunctions;
+    adapters: Adapters;
+    path: string;
+    pathRef: RefObject<string>;
+    infoRef: RefObject<InfoQueryData | undefined>;
+    queryParamsRef: RefObject<QueryParams | null>;
+    currentLanguage: string;
+}
+/** The options accepted by the provider's download action. */
+export interface DownloadActionOptions {
+    export_mode?: string;
+    delimiter?: string;
+    quotechar?: string;
+}
+/** The options accepted by the provider's upload action. */
+export interface UploadActionOptions {
+    delimiter?: string;
+    quotechar?: string;
+}
+/** The arguments accepted by `useStreamingData`. */
+export interface UseStreamingDataParams {
+    streamingMode: boolean;
+    dataQuery: UseQueryResult<DataPage | null>;
+    streamingQuery: UseInfiniteQueryResult<InfiniteData<StreamingPage | null>>;
+    streamingQueryKey: QueryKey;
+}
+/** The configuration object accepted by `useProvideApi`. */
+export interface UseProvideApiParams {
+    path: string;
+    initialQueryParams?: QueryParams;
+    relation?: RelationParam;
+    fetchInfo?: boolean;
+    clearInfoOnRefetch?: boolean;
+    clearDataOnRefetch?: boolean;
+    refetchInfoBasedOnLang?: boolean;
+    refetchDataBasedOnLang?: boolean;
+    resetQueryParamsOnPathChange?: boolean;
+    infoQueryProps?: Partial<UseQueryOptions<InfoQueryData>>;
+    dataQueryProps?: Partial<UseQueryOptions<DataPage | null>>;
+    streamingQueryProps?: Partial<UseInfiniteQueryOptions<StreamingPage | null, Error, InfiniteData<StreamingPage | null>, QueryKey, number>>;
+    streaming?: boolean;
+}
+export interface BulkActions {
+    /** An array of currently selected IDs for bulk actions. */
+    selectedIds: Array<string | number>;
+    /** A function to set the selected IDs. */
+    setSelectedIds: (ids: Array<string | number>) => void;
+}
+export interface BulkActionsContextValue {
+    /** An object containing the selected IDs and a function to set them. */
+    bulkActions: BulkActions;
+    /**
+     * Dispatches a bulk action; falls back to the currently selected IDs when `data` is omitted.
+     * Resolves to `undefined` when the action throws (the error is surfaced via `error`).
+     */
+    dispatchBulkActions: (handler: string, data?: Array<string | number>) => Promise<BulkActionResponse | undefined>;
+    /** An error object if the bulk action failed. */
+    error?: {
+        message: string;
+        originalError: Error;
+    };
+    /** A function to reset the error state. */
+    resetError: () => void;
+}
+export type FormType = 'view' | 'add' | 'edit' | 'delete';
+export type FormViewMode = 'normal' | 'fullScreen' | 'overlay';
+export interface FormState {
+    errors: ValidationError[];
+    data: EntryRow | undefined;
+}
+export interface FormsContextValue<TItem = EntryRow> {
+    /** Indicates whether the form is currently opened. */
+    opened: boolean;
+    /** A function to get the current opened state of the form. */
+    getOpened: () => boolean;
+    /** A function to set the opened state of the form. */
+    setOpened: (newOpened: boolean) => void;
+    /** The current view mode of the form. See `VIEW_MODE` from `@fastapi-rtk/constants` for more details. */
+    view: FormViewMode;
+    /** A function to get the current view mode of the form. */
+    getView: () => FormViewMode;
+    /** A function to set the view mode of the form. */
+    setView: (newView: FormViewMode) => void;
+    /** The current state of the form, including errors and data. */
+    state: FormState;
+    /** A function to get the current state of the form. */
+    getState: () => FormState;
+    /** A function to set the state of the form. */
+    setState: (newState: FormState) => void;
+    /** A function to reset the form state to its initial state. */
+    reset: () => void;
+    /** The current item being edited in the form, if applicable. */
+    item: TItem | undefined;
+    /** A function to get the current item in the form. */
+    getItem: () => TItem | undefined;
+    /** A function to set the current item in the form. */
+    setItem: (newItem: TItem | undefined) => void;
+}

package/dist/api/lib/ApiProvider/hooks/useProvideBulk.d.ts

@@ -0,0 +1,7 @@
+import { BulkActionsContextValue, BulkFunctions } from './types';
+export declare const defaultBulk: {
+    postBulk: (adapters: import('../..').Adapters, path: string, handler: string, data: import('../..').BulkActionPayload, options?: import('../..').FetchOptions) => Promise<import('../..').BulkActionResponse>;
+};
+export declare const useProvideBulk: (params: {
+    path: string;
+}, bulk?: BulkFunctions) => BulkActionsContextValue;