@firecms/core 3.0.0-alpha.8 → 3.0.0-alpha.80

package/dist/form/PropertyFieldBinding.d.ts

@@ -0,0 +1,30 @@
+import { ReactElement } from "react";
+import { CMSType, PropertyFieldBindingProps } from "../types";
+/**
+ * This component renders a form field creating the corresponding configuration
+ * from a property. For example if bound to a string property, it will generate
+ * a text field.
+ *
+ * You can use it when you are creating a custom field, and need to
+ * render additional fields mapped to properties. This is useful if you
+ * need to build a complex property mapping, like an array where each index
+ * is a different property.
+ *
+ * Please note that if you build a custom field in a component, the
+ * **validation** passed in the property will have no effect. You need to set
+ * the validation in the `EntityCollection` definition.
+ *
+ * @param propertyKey You can use nested names such as `address.street` or `friends[2]`
+ * @param property
+ * @param context
+ * @param includeDescription
+ * @param underlyingValueHasChanged
+ * @param disabled
+ * @param tableMode
+ * @param partOfArray
+ * @param autoFocus
+ * @group Form custom fields
+ */
+export declare const PropertyFieldBinding: typeof PropertyFieldBindingInternal;
+declare function PropertyFieldBindingInternal<T extends CMSType = CMSType, CustomProps = any, M extends Record<string, any> = Record<string, any>>({ propertyKey, property, context, includeDescription, underlyingValueHasChanged, disabled, tableMode, partOfArray, partOfBlock, autoFocus, }: PropertyFieldBindingProps<T, M>): ReactElement<PropertyFieldBindingProps<T, M>>;
+export {};

package/dist/form/components/CustomIdField.d.ts

@@ -0,0 +1,9 @@
+import { Entity, EntityStatus, EnumValues } from "../../types";
+export declare function CustomIdField<M extends Record<string, any>>({ customId, entityId, status, onChange, error, entity }: {
+    customId?: boolean | EnumValues | "optional";
+    entityId?: string;
+    status: EntityStatus;
+    onChange: (id?: string) => void;
+    error: boolean;
+    entity: Entity<M> | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/form/components/ErrorFocus.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const ErrorFocus: ({ containerRef }: {
+    containerRef?: React.RefObject<HTMLDivElement> | undefined;
+}) => null;

package/dist/form/components/FieldHelperText.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedProperty } from "../../types";
+/**
+ * Component in charge of rendering the description of a field
+ * as well as the error message if any.
+ */
+export declare function FieldHelperText({ error, showError, property, includeDescription, disabled }: {
+    error?: string;
+    showError: boolean;
+    property: ResolvedProperty;
+    includeDescription?: boolean;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/form/components/FormikArrayContainer.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+interface ArrayContainerProps<T> {
+    value: T[];
+    name: string;
+    addLabel: string;
+    buildEntry: (index: number, internalId: number) => React.ReactNode;
+    disabled?: boolean;
+    small?: boolean;
+    onInternalIdAdded?: (id: number) => void;
+    includeAddButton?: boolean;
+    newDefaultEntry?: T | null;
+    setFieldValue: (field: string, value: any, shouldValidate?: boolean | undefined) => void;
+}
+/**
+ * @group Form custom fields
+ */
+export declare function FormikArrayContainer<T>({ name, addLabel, value, disabled, buildEntry, small, onInternalIdAdded, includeAddButton, newDefaultEntry, setFieldValue }: ArrayContainerProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/components/StorageItemPreview.d.ts

@@ -0,0 +1,13 @@
+import { Entity, ResolvedStringProperty } from "../../types";
+import { PreviewSize } from "../../preview";
+interface StorageItemPreviewProps {
+    name: string;
+    property: ResolvedStringProperty;
+    value: string;
+    entity: Entity<any>;
+    onRemove: (value: string) => void;
+    size: PreviewSize;
+    disabled: boolean;
+}
+export declare function StorageItemPreview({ name, property, value, entity, onRemove, disabled, size }: StorageItemPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/components/StorageUploadProgress.d.ts

@@ -0,0 +1,10 @@
+import { StorageFieldItem } from "../../util/useStorageUploadController";
+export interface StorageUploadItemProps {
+    storagePath: string;
+    metadata?: any;
+    entry: StorageFieldItem;
+    onFileUploadComplete: (value: string, entry: StorageFieldItem, metadata?: any) => Promise<void>;
+    imageSize: number;
+    simple: boolean;
+}
+export declare function StorageUploadProgress({ storagePath, entry, metadata, onFileUploadComplete, imageSize, simple }: StorageUploadItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/form/components/SubmitListener.d.ts

@@ -0,0 +1 @@
+export declare function SubmitListener(): null;

package/dist/form/components/SwitchControl.d.ts

@@ -0,0 +1,8 @@
+import { FieldProps } from "formik";
+export declare function SwitchControl({ field, form, label, tooltip, disabled, size, allowIndeterminate }: FieldProps & {
+    label: string;
+    tooltip?: string;
+    disabled?: boolean;
+    size: "small" | "medium";
+    allowIndeterminate?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/form/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FormikArrayContainer";
+export * from "./SwitchControl";
+export * from "./FieldHelperText";

package/dist/form/field_bindings/ArrayCustomShapedFieldBinding.d.ts

@@ -0,0 +1,9 @@
+import { FieldProps } from "../../types";
+/**
+ * Array field used for custom
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function ArrayCustomShapedFieldBinding<T extends Array<any>>({ propertyKey, value, error, showError, isSubmitting, setValue, tableMode, property, includeDescription, underlyingValueHasChanged, context, disabled }: FieldProps<T, any, any>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/ArrayOfReferencesFieldBinding.d.ts

@@ -0,0 +1,11 @@
+import { EntityReference, FieldProps } from "../../types";
+type ArrayOfReferencesFieldProps = FieldProps<EntityReference[]>;
+/**
+ * This field allows selecting multiple references.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function ArrayOfReferencesFieldBinding({ propertyKey, value, error, showError, disabled, isSubmitting, tableMode, property, includeDescription, setValue, setFieldValue }: ArrayOfReferencesFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/field_bindings/BlockFieldBinding.d.ts

@@ -0,0 +1,10 @@
+import { FieldProps } from "../../types";
+/**
+ * If the `oneOf` property is specified, this fields render each array entry as
+ * a `type` select and the corresponding field widget to the selected `type.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function BlockFieldBinding<T extends Array<any>>({ propertyKey, value, error, showError, isSubmitting, setValue, setFieldValue, tableMode, property, includeDescription, underlyingValueHasChanged, context, disabled }: FieldProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/DateTimeFieldBinding.d.ts

@@ -0,0 +1,11 @@
+import { FieldProps } from "../../types";
+type DateTimeFieldProps = FieldProps<Date>;
+/**
+ * Field that allows selecting a date
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function DateTimeFieldBinding({ propertyKey, value, setValue, autoFocus, error, showError, disabled, touched, property, includeDescription }: DateTimeFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/field_bindings/KeyValueFieldBinding.d.ts

@@ -0,0 +1,7 @@
+import { FieldProps } from "../../types";
+/**
+ * Field that allows edition of key value pairs.
+ *
+ * @group Form fields
+ */
+export declare function KeyValueFieldBinding<T extends Record<string, any>>({ propertyKey, value, showError, error, disabled, property, setValue, tableMode, includeDescription, underlyingValueHasChanged, autoFocus, context }: FieldProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/MapFieldBinding.d.ts

@@ -0,0 +1,9 @@
+import { FieldProps } from "../../types";
+/**
+ * Field that renders the children property fields
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function MapFieldBinding<T extends Record<string, any>>({ propertyKey, value, showError, error, disabled, property, setValue, partOfBlock, tableMode, includeDescription, underlyingValueHasChanged, autoFocus, context }: FieldProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/MarkdownFieldBinding.d.ts

@@ -0,0 +1,9 @@
+import { FieldProps } from "../../types";
+/**
+ * Render a markdown field that allows edition and seeing the preview.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function MarkdownFieldBinding({ propertyKey, value, setValue, error, showError, disabled, autoFocus, touched, property, tableMode, includeDescription, context }: FieldProps<string>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/MultiSelectBinding.d.ts

@@ -0,0 +1,9 @@
+import { EnumType, FieldProps } from "../../types";
+/**
+ * This fields renders a dropdown with multiple selection.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function MultiSelectBinding({ propertyKey, value, setValue, error, showError, disabled, property, includeDescription, autoFocus }: FieldProps<EnumType[], any, any>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/ReadOnlyFieldBinding.d.ts

@@ -0,0 +1,10 @@
+import { FieldProps } from "../../types";
+/**
+ *
+ * Simply render the non-editable preview of a field
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function ReadOnlyFieldBinding({ propertyKey, value, error, showError, tableMode, property, includeDescription, context }: FieldProps<any>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/ReferenceFieldBinding.d.ts

@@ -0,0 +1,9 @@
+import { EntityReference, FieldProps } from "../../types";
+/**
+ * Field that opens a reference selection dialog.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function ReferenceFieldBinding<M extends Record<string, any>>(props: FieldProps<EntityReference>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/RepeatFieldBinding.d.ts

@@ -0,0 +1,10 @@
+import { FieldProps } from "../../types";
+/**
+ * Generic array field that allows reordering and renders the child property
+ * as nodes.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function RepeatFieldBinding<T extends Array<any>>({ propertyKey, value, error, showError, isSubmitting, setValue, setFieldValue, tableMode, property, includeDescription, underlyingValueHasChanged, context, disabled }: FieldProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/form/field_bindings/SelectFieldBinding.d.ts

@@ -0,0 +1,12 @@
+import { EnumType, FieldProps } from "../../types";
+type SelectProps<T extends EnumType> = FieldProps<T>;
+/**
+ * If `enumValues` are set in the string config, this field renders a select
+ * where each option is a colored chip.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function SelectFieldBinding<T extends EnumType>({ propertyKey, value, setValue, error, showError, disabled, autoFocus, touched, property, includeDescription }: SelectProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/field_bindings/StorageUploadFieldBinding.d.ts

@@ -0,0 +1,28 @@
+import { Entity, FieldProps, ResolvedArrayProperty, ResolvedStringProperty, StorageConfig } from "../../types";
+import { StorageFieldItem } from "../../util/useStorageUploadController";
+type StorageUploadFieldProps = FieldProps<string | string[]>;
+/**
+ * Field that allows to upload files to Google Cloud Storage.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function StorageUploadFieldBinding({ propertyKey, value, setValue, error, showError, autoFocus, tableMode, property, includeDescription, context, isSubmitting }: StorageUploadFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface StorageUploadProps {
+    value: StorageFieldItem[];
+    setInternalValue: (v: StorageFieldItem[]) => void;
+    name: string;
+    property: ResolvedStringProperty | ResolvedArrayProperty<string[]>;
+    onChange: (value: string | string[] | null) => void;
+    multipleFilesSupported: boolean;
+    autoFocus: boolean;
+    disabled: boolean;
+    entity: Entity<any>;
+    storage: StorageConfig;
+    onFilesAdded: (acceptedFiles: File[]) => void;
+    storagePathBuilder: (file: File) => string;
+    onFileUploadComplete: (uploadedPath: string, entry: StorageFieldItem, fileMetadata?: any) => Promise<void>;
+}
+export declare function StorageUpload({ property, name, value, setInternalValue, onChange, multipleFilesSupported, onFileUploadComplete, disabled, onFilesAdded, autoFocus, storage, entity, storagePathBuilder }: StorageUploadProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/field_bindings/SwitchFieldBinding.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { FieldProps } from "../../types";
+type SwitchFieldProps = FieldProps<boolean>;
+/**
+ * Simple boolean switch biding to a boolean property.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare const SwitchFieldBinding: React.ForwardRefExoticComponent<SwitchFieldProps & React.RefAttributes<unknown>>;
+export {};

package/dist/form/field_bindings/TextFieldBinding.d.ts

@@ -0,0 +1,12 @@
+import { FieldProps } from "../../types";
+interface TextFieldProps<T extends string | number> extends FieldProps<T> {
+    allowInfinity?: boolean;
+}
+/**
+ * Generic text field.
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function TextFieldBinding<T extends string | number>({ propertyKey, value, setValue, error, showError, disabled, autoFocus, property, includeDescription, }: TextFieldProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/index.d.ts

@@ -0,0 +1,20 @@
+import { SelectFieldBinding } from "./field_bindings/SelectFieldBinding";
+import { MultiSelectBinding } from "./field_bindings/MultiSelectBinding";
+import { ArrayOfReferencesFieldBinding } from "./field_bindings/ArrayOfReferencesFieldBinding";
+import { StorageUploadFieldBinding } from "./field_bindings/StorageUploadFieldBinding";
+import { TextFieldBinding } from "./field_bindings/TextFieldBinding";
+import { SwitchFieldBinding } from "./field_bindings/SwitchFieldBinding";
+import { DateTimeFieldBinding } from "./field_bindings/DateTimeFieldBinding";
+import { ReferenceFieldBinding } from "./field_bindings/ReferenceFieldBinding";
+import { MapFieldBinding } from "./field_bindings/MapFieldBinding";
+import { KeyValueFieldBinding } from "./field_bindings/KeyValueFieldBinding";
+import { RepeatFieldBinding } from "./field_bindings/RepeatFieldBinding";
+import { BlockFieldBinding } from "./field_bindings/BlockFieldBinding";
+import { ReadOnlyFieldBinding } from "./field_bindings/ReadOnlyFieldBinding";
+import { MarkdownFieldBinding } from "./field_bindings/MarkdownFieldBinding";
+import { ArrayCustomShapedFieldBinding } from "./field_bindings/ArrayCustomShapedFieldBinding";
+export { ArrayCustomShapedFieldBinding, RepeatFieldBinding, MultiSelectBinding, ArrayOfReferencesFieldBinding, BlockFieldBinding, DateTimeFieldBinding, ReadOnlyFieldBinding, MapFieldBinding, KeyValueFieldBinding, ReferenceFieldBinding, SelectFieldBinding, StorageUploadFieldBinding, SwitchFieldBinding, MarkdownFieldBinding, TextFieldBinding };
+export * from "./components";
+export type { EntityFormProps } from "./EntityForm";
+export { EntityForm } from "./EntityForm";
+export { PropertyFieldBinding } from "./PropertyFieldBinding";

package/dist/form/useClearRestoreValue.d.ts

@@ -0,0 +1,13 @@
+import { CMSType, ResolvedProperty } from "../types";
+/**
+ * Hook we use to restore a value after it has been cleared
+ * @param property
+ * @param value
+ * @param setValue
+ * @ignore
+ */
+export declare function useClearRestoreValue<T extends CMSType>({ property, value, setValue }: {
+    property: ResolvedProperty<T>;
+    value: T;
+    setValue: (value: T | null, shouldValidate?: boolean) => void;
+}): void;

package/dist/form/validation.d.ts

@@ -0,0 +1,25 @@
+import { CMSType, ResolvedArrayProperty, ResolvedMapProperty, ResolvedProperties, ResolvedProperty } from "../types";
+import { AnySchema, ObjectSchema } from "yup";
+declare module "yup" {
+    interface ArraySchema<T> {
+        uniqueInArray(mapper: (a: T) => T, message: string): ArraySchema<T>;
+    }
+}
+export type CustomFieldValidator = (props: {
+    name: string;
+    value: any;
+    property: ResolvedProperty;
+    entityId?: string;
+    parentProperty?: ResolvedMapProperty | ResolvedArrayProperty;
+}) => Promise<boolean>;
+interface PropertyContext<T extends CMSType> {
+    property: ResolvedProperty<T>;
+    parentProperty?: ResolvedMapProperty | ResolvedArrayProperty;
+    entityId: string;
+    customFieldValidator?: CustomFieldValidator;
+    name?: any;
+}
+export declare function getYupEntitySchema<M extends Record<string, any>>(entityId: string, properties: ResolvedProperties<M>, customFieldValidator?: CustomFieldValidator): ObjectSchema<any>;
+export declare function mapPropertyToYup<T extends CMSType>(propertyContext: PropertyContext<T>): AnySchema<unknown>;
+export declare function getYupMapObjectSchema<M extends Record<string, any>>({ property, entityId, customFieldValidator, name }: PropertyContext<M>): ObjectSchema<any>;
+export {};

package/dist/hooks/data/delete.d.ts

@@ -0,0 +1,37 @@
+import { DataSource, DeleteEntityProps, Entity, EntityCallbacks, FireCMSContext, ResolvedEntityCollection, User } from "../../types";
+/**
+ * @group Hooks and utilities
+ */
+export type DeleteEntityWithCallbacksProps<M extends Record<string, any>> = DeleteEntityProps<M> & {
+    callbacks?: EntityCallbacks<M>;
+    onDeleteSuccess?: (entity: Entity<M>) => void;
+    onDeleteFailure?: (entity: Entity<M>, e: Error) => void;
+    onPreDeleteHookError?: (entity: Entity<M>, e: Error) => void;
+    onDeleteSuccessHookError?: (entity: Entity<M>, e: Error) => void;
+};
+/**
+ * This function is in charge of deleting an entity in the datasource.
+ * It will run all the delete callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * If you just want to delete any data without running the `onPreDelete`,
+ * and `onDelete` callbacks, you can use the `deleteEntity` method
+ * in the datasource ({@link useDataSource}).
+ *
+ * @param dataSource
+ * @param entity
+ * @param collection
+ * @param callbacks
+ * @param onDeleteSuccess
+ * @param onDeleteFailure
+ * @param onPreDeleteHookError
+ * @param onDeleteSuccessHookError
+ * @param context
+ * @group Hooks and utilities
+ */
+export declare function deleteEntityWithCallbacks<M extends Record<string, any>, UserType extends User>({ dataSource, entity, collection, callbacks, onDeleteSuccess, onDeleteFailure, onPreDeleteHookError, onDeleteSuccessHookError, context }: DeleteEntityWithCallbacksProps<M> & {
+    collection: ResolvedEntityCollection<M>;
+    dataSource: DataSource;
+    context: FireCMSContext<UserType>;
+}): Promise<boolean>;

package/dist/hooks/data/save.d.ts

@@ -0,0 +1,42 @@
+import { DataSource, Entity, EntityCallbacks, EntityCollection, FireCMSContext, SaveEntityProps, User } from "../../types";
+/**
+ * @group Hooks and utilities
+ */
+export type SaveEntityWithCallbacksProps<M extends Record<string, any>> = SaveEntityProps<M> & {
+    callbacks?: EntityCallbacks<M>;
+    onSaveSuccess?: (updatedEntity: Entity<M>) => void;
+    onSaveFailure?: (e: Error) => void;
+    onPreSaveHookError?: (e: Error) => void;
+    onSaveSuccessHookError?: (e: Error) => void;
+};
+/**
+ * This function is in charge of saving an entity to the datasource.
+ * It will run all the save callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * If you just want to save the data without running the `onSaveSuccess`,
+ * `onSaveFailure` and `onPreSave` callbacks, you can use the `saveEntity` method
+ * in the datasource ({@link useDataSource}).
+ *
+ * @param collection
+ * @param path
+ * @param entityId
+ * @param callbacks
+ * @param values
+ * @param previousValues
+ * @param status
+ * @param dataSource
+ * @param context
+ * @param onSaveSuccess
+ * @param onSaveFailure
+ * @param onPreSaveHookError
+ * @param onSaveSuccessHookError
+ * @see useDataSource
+ * @group Hooks and utilities
+ */
+export declare function saveEntityWithCallbacks<M extends Record<string, any>, UserType extends User>({ collection, path, entityId, values, previousValues, status, dataSource, context, onSaveSuccess, onSaveFailure, onPreSaveHookError, onSaveSuccessHookError }: SaveEntityWithCallbacksProps<M> & {
+    collection: EntityCollection<M>;
+    dataSource: DataSource;
+    context: FireCMSContext<UserType>;
+}): Promise<void>;

package/dist/hooks/data/useCollectionFetch.d.ts

@@ -0,0 +1,50 @@
+import { Entity, EntityCollection, FilterValues, User } from "../../types";
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchProps<M extends Record<string, any>> {
+    /**
+     * Absolute collection path
+     */
+    path: string;
+    /**
+     * collection of the entity displayed by this collection
+     */
+    collection: EntityCollection<M>;
+    /**
+     * Number of entities to fetch
+     */
+    itemCount?: number;
+    /**
+     * Filter the fetched data by the property
+     */
+    filterValues?: FilterValues<Extract<keyof M, string>>;
+    /**
+     * Sort the results by
+     */
+    sortBy?: [Extract<keyof M, string>, "asc" | "desc"];
+    /**
+     * Search string
+     */
+    searchString?: string;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchResult<M extends Record<string, any>> {
+    data: Entity<M>[];
+    dataLoading: boolean;
+    noMoreToLoad: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * This hook is used to fetch collections using a given collection
+ * @param path
+ * @param collection
+ * @param filterValues
+ * @param sortBy
+ * @param itemCount
+ * @param searchString
+ * @group Hooks and utilities
+ */
+export declare function useCollectionFetch<M extends Record<string, any>, UserType extends User>({ path: inputPath, collection, filterValues, sortBy, itemCount, searchString }: CollectionFetchProps<M>): CollectionFetchResult<M>;

package/dist/hooks/data/useDataOrder.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from "../../types";
+export interface DataOrderProps<M extends Record<string, any>> {
+    data: Entity<M>[];
+    entitiesDisplayedFirst?: Entity<M>[];
+}
+/**
+ * This hook is used to have some entities at the beginning of data.
+ * @param path
+ * @param entitiesDisplayedFirst
+ * @group Hooks and utilities
+ */
+export declare function useDataOrder<M extends Record<string, any>>({ data, entitiesDisplayedFirst }: DataOrderProps<M>): Entity<M>[];

package/dist/hooks/data/useDataSource.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from "../../types";
+/**
+ * Use this hook to get the datasource being used
+ * @group Hooks and utilities
+ */
+export declare const useDataSource: () => DataSource;

package/dist/hooks/data/useEntityFetch.d.ts

@@ -0,0 +1,28 @@
+import { Entity, EntityCollection, User } from "../../types";
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchProps<M extends Record<string, any>> {
+    path: string;
+    entityId?: string;
+    collection: EntityCollection<M>;
+    useCache?: boolean;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchResult<M extends Record<string, any>> {
+    entity?: Entity<M>;
+    dataLoading: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * This hook is used to fetch an entity.
+ * It gives real time updates if the datasource supports it.
+ * @param path
+ * @param collection
+ * @param entityId
+ * @param useCache
+ * @group Hooks and utilities
+ */
+export declare function useEntityFetch<M extends Record<string, any>, UserType extends User>({ path: inputPath, entityId, collection, useCache }: EntityFetchProps<M>): EntityFetchResult<M>;

package/dist/hooks/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./data/useDataSource";
+export * from "./data/useCollectionFetch";
+export * from "./data/useEntityFetch";
+export * from "./data/save";
+export * from "./data/delete";
+export * from "../form/useClearRestoreValue";
+export * from "./useNavigationController";
+export * from "./useResolvedNavigationFrom";
+export * from "./useStorageSource";
+export * from "./useAuthController";
+export * from "./useSideDialogsController";
+export * from "./useSideEntityController";
+export * from "./useFireCMSContext";
+export * from "./useSnackbarController";
+export * from "./useModeController";
+export * from "./useClipboard";
+export * from "./useLargeLayout";
+export * from "./useReferenceDialog";
+export * from "./useBrowserTitleAndIcon";

package/dist/hooks/useAuthController.d.ts

@@ -0,0 +1,11 @@
+import { AuthController, User } from "../types";
+/**
+ * Hook to retrieve the AuthContext.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `FireCMS`
+ *
+ * @see AuthController
+ * @group Hooks and utilities
+ */
+export declare const useAuthController: <UserType extends User = User, AuthControllerType extends AuthController<UserType> = AuthController<UserType>>() => AuthControllerType;

package/dist/hooks/useBrowserTitleAndIcon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal hook to handle the browser title and icon
+ * @param name
+ * @param logo
+ */
+export declare function useBrowserTitleAndIcon(name: string, logo?: string): void;