@rebasepro/core 0.0.1-canary.0

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

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function FormLayout({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,14 @@
+import React from "react";
+interface LabelWithIconProps {
+    icon: React.ReactNode;
+    title?: string;
+    small?: boolean;
+    className?: string;
+    required?: boolean;
+}
+/**
+ * Render the label of with an icon and the title of a property
+ * @group Form custom fields
+ */
+export declare const LabelWithIcon: React.ForwardRefExoticComponent<LabelWithIconProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,15 @@
+import React from "react";
+interface LabelWithIconAndTooltip {
+    icon: React.ReactNode;
+    title?: string;
+    small?: boolean;
+    className?: string;
+    required?: boolean;
+    propertyKey: string;
+}
+/**
+ * Render the label of with an icon and the title of a property
+ * @group Form custom fields
+ */
+export declare function LabelWithIconAndTooltip({ propertyKey, className, ...props }: LabelWithIconAndTooltip): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import { FormexController } from "@rebasepro/formex";
+import { Properties } from "@rebasepro/types";
+interface LocalChangesMenuProps<M extends Record<string, any>> {
+    cacheKey: string;
+    cachedData: Partial<M>;
+    formex: FormexController<M>;
+    onClearLocalChanges?: () => void;
+    properties: Properties;
+}
+export declare function LocalChangesMenu<M extends Record<string, any>>({ cachedData, formex, onClearLocalChanges, cacheKey, properties }: LocalChangesMenuProps<M>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+import { PreviewSize, StringProperty } from "@rebasepro/types";
+interface StorageItemPreviewProps {
+    name: string;
+    property: StringProperty;
+    value: string;
+    onRemove: (value: string) => void;
+    size: PreviewSize;
+    disabled: boolean;
+    placeholder?: boolean;
+    className?: string;
+}
+export declare function StorageItemPreview({ name, property, value, onRemove, disabled, size, placeholder, className }: 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, uploadedUrl?: string) => 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/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./FieldHelperText";
+export * from "./LabelWithIcon";
+export * from "./LabelWithIconAndTooltip";
+export * from "./FormEntry";
+export * from "./FormLayout";

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

@@ -0,0 +1,9 @@
+import { ArrayProperty, FieldProps } from "@rebasepro/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({ propertyKey, value, error, showError, isSubmitting, setValue, setFieldValue, customProps, minimalistView: minimalistViewProp, property, includeDescription, context, disabled }: FieldProps<ArrayProperty | ArrayProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { ArrayProperty, EntityReference, FieldProps } from "@rebasepro/types";
+type ArrayOfReferencesFieldProps = FieldProps<ArrayProperty, 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, minimalistView: minimalistViewProp, 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 { ArrayProperty, FieldProps } from "@rebasepro/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({ propertyKey, value, error, showError, isSubmitting, setValue, setFieldValue, minimalistView: minimalistViewProp, property, includeDescription, underlyingValueHasChanged, context, disabled }: FieldProps<ArrayProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { DateProperty, FieldProps } from "@rebasepro/types";
+type DateTimeFieldProps = FieldProps<DateProperty>;
+/**
+ * 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, MapProperty } from "@rebasepro/types";
+/**
+ * Field that allows edition of key value pairs.
+ *
+ * @group Form fields
+ */
+export declare function KeyValueFieldBinding({ propertyKey, value, showError, error, disabled, property, setValue, minimalistView, includeDescription, underlyingValueHasChanged, autoFocus, context }: FieldProps<MapProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { FieldProps, MapProperty } from "@rebasepro/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({ propertyKey, value, showError, error, disabled, property, partOfArray, minimalistView: minimalistViewProp, includeDescription, autoFocus, context, onPropertyChange }: FieldProps<MapProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { FieldProps, StringProperty } from "../../index";
+import { RebaseEditorProps } from "@rebasepro/editor";
+interface MarkdownEditorFieldProps {
+    highlight?: {
+        from: number;
+        to: number;
+    };
+    editorProps?: Partial<RebaseEditorProps>;
+}
+export declare function MarkdownEditorFieldBinding({ property, propertyKey, value, setValue, includeDescription, showError, error, minimalistView, disabled: disabledProp, isSubmitting, context, customProps, }: FieldProps<StringProperty, MarkdownEditorFieldProps>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { ArrayProperty, FieldProps } from "@rebasepro/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 MultiSelectFieldBinding({ propertyKey, value, setValue, error, showError, disabled, property, includeDescription, size, autoFocus }: FieldProps<ArrayProperty, any, any>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { FieldProps, RelationProperty } from "@rebasepro/types";
+/**
+ * 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 MultipleRelationFieldBinding({ propertyKey, value: valueProp, error, showError, disabled, isSubmitting, property, includeDescription, setValue, setFieldValue, context }: FieldProps<RelationProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { FieldProps, Property } from "@rebasepro/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, minimalistView, property, includeDescription, context }: FieldProps<Property>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { FieldProps, StringProperty } from "@rebasepro/types";
+/**
+ * Field that opens a reference selection dialog and stores the entity ID as a string.
+ *
+ * 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 ReferenceAsStringFieldBinding(props: FieldProps<StringProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { FieldProps, ReferenceProperty } from "@rebasepro/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(props: FieldProps<ReferenceProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { FieldProps, RelationProperty } from "@rebasepro/types";
+export declare function RelationFieldBinding({ propertyKey, value, size, error, showError, disabled, isSubmitting, property, includeDescription, setValue, setFieldValue, context, customProps }: FieldProps<RelationProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { ArrayProperty, FieldProps } from "@rebasepro/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({ propertyKey, value, error, showError, isSubmitting, setValue, setFieldValue, minimalistView: minimalistViewProp, property, includeDescription, underlyingValueHasChanged, context, disabled }: FieldProps<ArrayProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { FieldProps, NumberProperty, StringProperty } from "@rebasepro/types";
+/**
+ * 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({ propertyKey, value, setValue, error, showError, disabled, autoFocus, touched, property, includeDescription, size }: FieldProps<StringProperty | NumberProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,19 @@
+import { ArrayProperty, FieldProps, StorageConfig, StringProperty } from "@rebasepro/types";
+import { StorageFieldItem } from "../../util/useStorageUploadController";
+export declare function StorageUploadFieldBinding({ propertyKey, value, setValue, error, showError, autoFocus, minimalistView, property, includeDescription, context, isSubmitting, }: FieldProps<StringProperty | ArrayProperty>): import("react/jsx-runtime").JSX.Element;
+export interface StorageUploadProps {
+    value: StorageFieldItem[];
+    setInternalValue: (v: StorageFieldItem[]) => void;
+    name: string;
+    property: StringProperty | ArrayProperty;
+    onChange: (value: string | string[] | null) => void;
+    multipleFilesSupported: boolean;
+    autoFocus: boolean;
+    disabled: boolean;
+    storage: StorageConfig;
+    onFilesAdded: (acceptedFiles: File[]) => Promise<void>;
+    storagePathBuilder: (file: File) => string;
+    onFileUploadComplete: (uploadedPath: string, entry: StorageFieldItem, fileMetadata?: any) => Promise<void>;
+}
+export declare function StorageUpload({ property, name, value, // This is internalValue from useStorageUploadController
+setInternalValue, onChange, multipleFilesSupported, onFileUploadComplete, disabled, onFilesAdded, autoFocus, storage, storagePathBuilder, }: StorageUploadProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { BooleanProperty, FieldProps } from "@rebasepro/types";
+/**
+ * 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: ({ propertyKey, value, setValue, error, showError, autoFocus, disabled, size, property, includeDescription }: FieldProps<BooleanProperty>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { FieldProps, NumberProperty, StringProperty } from "@rebasepro/types";
+/**
+ * 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, size }: FieldProps<StringProperty | NumberProperty>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { FieldProps, StringProperty } from "@rebasepro/types";
+type UserSelectProps = FieldProps<StringProperty>;
+/**
+ * Field binding for selecting a user from the internal user management system.
+ * Renders a select dropdown with user information including name and email.
+ *
+ * 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 UserSelectFieldBinding({ propertyKey, value, setValue, error, showError, disabled, autoFocus, touched, property, includeDescription, size }: UserSelectProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/index.d.ts

@@ -0,0 +1,20 @@
+export { EntityForm, yupToFormErrors, } from "./EntityForm";
+export { SelectFieldBinding } from "./field_bindings/SelectFieldBinding";
+export { MultiSelectFieldBinding } from "./field_bindings/MultiSelectFieldBinding";
+export { ArrayOfReferencesFieldBinding } from "./field_bindings/ArrayOfReferencesFieldBinding";
+export { StorageUploadFieldBinding } from "./field_bindings/StorageUploadFieldBinding";
+export { TextFieldBinding } from "./field_bindings/TextFieldBinding";
+export { SwitchFieldBinding } from "./field_bindings/SwitchFieldBinding";
+export { DateTimeFieldBinding } from "./field_bindings/DateTimeFieldBinding";
+export { ReferenceFieldBinding } from "./field_bindings/ReferenceFieldBinding";
+export { ReferenceAsStringFieldBinding } from "./field_bindings/ReferenceAsStringFieldBinding";
+export { MapFieldBinding } from "./field_bindings/MapFieldBinding";
+export { KeyValueFieldBinding } from "./field_bindings/KeyValueFieldBinding";
+export { RepeatFieldBinding } from "./field_bindings/RepeatFieldBinding";
+export { BlockFieldBinding } from "./field_bindings/BlockFieldBinding";
+export { ReadOnlyFieldBinding } from "./field_bindings/ReadOnlyFieldBinding";
+export { MarkdownEditorFieldBinding } from "./field_bindings/MarkdownEditorFieldBinding";
+export { ArrayCustomShapedFieldBinding } from "./field_bindings/ArrayCustomShapedFieldBinding";
+export * from "./components";
+export { PropertyFieldBinding } from "./PropertyFieldBinding";
+export * from "./useClearRestoreValue";

package/dist/form/useClearRestoreValue.d.ts

@@ -0,0 +1,13 @@
+import { Property } from "@rebasepro/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>({ property, value, setValue }: {
+    property: Property;
+    value: T | null;
+    setValue: (value: T | null, shouldValidate?: boolean) => void;
+}): void;

package/dist/form/validation.d.ts

@@ -0,0 +1,26 @@
+import { ArrayProperty, MapProperty, Property, Properties } from "@rebasepro/types";
+import * as yup from "yup";
+import { AnySchema, ObjectSchema } from "yup";
+declare module "yup" {
+    interface ArraySchema<TIn extends any[] | null | undefined, TContext, TDefault = undefined, TFlags extends yup.Flags = ""> {
+        uniqueInArray(mapper: (a: any) => any, message: string): ArraySchema<TIn, TContext, TDefault, TFlags>;
+    }
+}
+export type CustomFieldValidator = (props: {
+    name: string;
+    value: any;
+    property: Property;
+    entityId?: string | number;
+    parentProperty?: MapProperty | ArrayProperty;
+}) => Promise<boolean>;
+interface PropertyContext<P extends Property> {
+    property: P;
+    parentProperty?: MapProperty | ArrayProperty;
+    entityId?: string | number;
+    customFieldValidator?: CustomFieldValidator;
+    name?: any;
+}
+export declare function getYupEntitySchema<M extends Record<string, any>>(entityId: string | number | undefined, properties: Properties, customFieldValidator?: CustomFieldValidator): ObjectSchema<any>;
+export declare function mapPropertyToYup(propertyContext: PropertyContext<Property>): AnySchema<unknown>;
+export declare function getYupMapObjectSchema({ property, entityId, customFieldValidator, name }: PropertyContext<MapProperty>): ObjectSchema<any>;
+export {};

package/dist/hooks/ApiConfigContext.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+/**
+ * Configuration for API connectivity. Passed once at the top level
+ * and available to any hook that needs `apiUrl` or `getAuthToken`.
+ *
+ * Individual hooks can still accept explicit overrides — this context
+ * serves as a fallback to eliminate repetitive threading.
+ */
+export interface ApiConfig {
+    apiUrl: string;
+    getAuthToken?: () => Promise<string | null>;
+}
+/**
+ * Read the API config from context. Returns `undefined` if no provider is present,
+ * allowing hooks to fall back to their own props.
+ */
+export declare function useApiConfig(): ApiConfig | undefined;
+/**
+ * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * Typically rendered inside `<Rebase>` or at the app root.
+ */
+export declare function ApiConfigProvider({ apiUrl, getAuthToken, children }: ApiConfig & {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,33 @@
+import { DataSource, DeleteEntityProps, Entity, EntityCallbacks, EntityCollection, RebaseContext, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export type DeleteEntityWithCallbacksProps<M extends Record<string, any>, USER extends User = User> = DeleteEntityProps<M> & {
+    callbacks?: EntityCallbacks<M, USER>;
+    onDeleteSuccess?: (entity: Entity<M>) => void;
+    onDeleteFailure?: (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 `beforeDelete`,
+ * and `afterDelete` 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 context
+ * @group Hooks and utilities
+ */
+export declare function deleteEntityWithCallbacks<M extends Record<string, any>, USER extends User>({ dataSource, entity, collection, callbacks, onDeleteSuccess, onDeleteFailure, context }: DeleteEntityWithCallbacksProps<M> & {
+    collection: EntityCollection<M>;
+    dataSource: DataSource;
+    context: RebaseContext<USER>;
+}): Promise<boolean>;

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

@@ -0,0 +1,37 @@
+import { DataSource, Entity, EntityCollection, RebaseContext, SaveEntityProps } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export type SaveEntityWithCallbacksProps<M extends Record<string, any>> = SaveEntityProps<M> & {
+    afterSave?: (updatedEntity: Entity<M>) => void;
+    afterSaveError?: (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 `afterSave`,
+ * `afterSaveError` and `beforeSave` 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 afterSave
+ * @param afterSaveError
+ * @see useDataSource
+ * @group Hooks and utilities
+ */
+export declare function saveEntityWithCallbacks<M extends Record<string, any>>({ collection, path, entityId, values, previousValues, status, dataSource, context, afterSave, afterSaveError }: SaveEntityWithCallbacksProps<M> & {
+    collection: EntityCollection;
+    dataSource: DataSource;
+    context: RebaseContext;
+}): Promise<Entity<M>>;

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

@@ -0,0 +1,50 @@
+import { Entity, EntityCollection, FilterValues, User } from "@rebasepro/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>, USER 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 "@rebasepro/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, EntityCollection } from "@rebasepro/types";
+/**
+ * Use this hook to get the datasource being used
+ * @group Hooks and utilities
+ */
+export declare const useDataSource: (collection?: EntityCollection<any, any>) => DataSource;

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

@@ -0,0 +1,29 @@
+import { Entity, EntityCollection, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchProps<M extends Record<string, any>, USER extends User = User> {
+    path: string;
+    entityId?: string | number;
+    databaseId?: string;
+    collection: EntityCollection<M, USER>;
+    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>, USER extends User>({ path: inputPath, entityId, collection, databaseId, useCache }: EntityFetchProps<M, USER>): EntityFetchResult<M>;

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

@@ -0,0 +1,45 @@
+import { Entity, EntityCollection, EntityRelation, FilterValues } from "@rebasepro/types";
+import { RelationItem } from "../../components/RelationSelector";
+export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
+    /**
+     * Full path where the relation data is located
+     */
+    path: string;
+    /**
+     * The collection that represents the relation entities
+     */
+    collection: EntityCollection<M>;
+    /**
+     * Force filter to be applied to the relation search
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Page size for pagination
+     */
+    pageSize?: number;
+    /**
+     * Function to extract the label from an entity
+     */
+    getLabelFromEntity?: (entity: Entity<M>) => string;
+    /**
+     * Function to extract the description from an entity
+     */
+    getDescriptionFromEntity?: (entity: Entity<M>) => string | undefined;
+    /**
+     * Property name to use as the secondary display field
+     */
+    descriptionProperty?: keyof M;
+}
+export interface RelationSelectorController {
+    items: RelationItem[];
+    isLoading: boolean;
+    error: Error | undefined;
+    search: (searchString: string) => void;
+    loadMore: () => void;
+    hasMore: boolean;
+    entityToRelationItem: (entity: Entity<any>, relation: EntityRelation) => RelationItem;
+}
+/**
+ * Hook to manage relation selection with data fetching from Rebase data source
+ */
+export declare function useRelationSelector<M extends Record<string, any> = any>({ path, collection, forceFilter, pageSize, getLabelFromEntity, getDescriptionFromEntity, descriptionProperty }: UseRelationSelectorProps<M>): RelationSelectorController;