@bluealba/pae-ui-react-core 3.0.2-feature-rename-ba-libraries-scope-1169

package/dist/src/components/common/Table/Table.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+
+export type SortDirection = 'asc' | 'desc';
+export type SortType = {
+    field: string;
+    direction: SortDirection;
+    onSort: (field: string, direction: SortDirection) => void;
+};
+export type PaginationType = {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+};
+export type ColumnType<T> = {
+    name: string;
+    displayName: string;
+    align?: 'left' | 'center' | 'right';
+    isSortable?: boolean;
+    sortName?: string;
+    width?: number;
+    valueGetter?: (row: T) => string | number;
+    cellRenderer?: (row: T) => ReactNode | null;
+};
+export type LoadingConfigType = {
+    count?: number;
+    height?: number;
+};
+type TableProps<T> = {
+    isLoading?: boolean;
+    columns: ColumnType<T>[];
+    data: T[];
+    totalCount?: number;
+    headerLabel?: string;
+    sort?: SortType;
+    pagination?: PaginationType;
+    loadingConfig?: LoadingConfigType;
+    onRowClick?: (row: T) => void;
+};
+declare const Table: {
+    <T>({ columns, data, isLoading, totalCount, headerLabel, sort, loadingConfig, pagination, onRowClick }: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default Table;

package/dist/src/components/common/Table/Table.stories.d.ts

@@ -0,0 +1,65 @@
+import { default as Table } from './Table';
+declare namespace _default {
+    export let title: string;
+    export { Table as component };
+    export let tags: string[];
+}
+export default _default;
+export namespace Default {
+    namespace args {
+        export { columns };
+        export { data };
+    }
+}
+export namespace CustomLoadingConfig {
+    export namespace args_1 {
+        export { columns };
+        export { data };
+        export let isLoading: boolean;
+        export namespace loadingConfig {
+            let count: number;
+            let height: number;
+        }
+    }
+    export { args_1 as args };
+}
+export namespace WithRowClick {
+    export namespace args_2 {
+        export { columns };
+        export { data };
+        export let onRowClick: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    }
+    export { args_2 as args };
+}
+export namespace ServerSideData {
+    export namespace args_3 {
+        export { columns };
+    }
+    export { args_3 as args };
+    export function render(args: any): import("react/jsx-runtime").JSX.Element;
+}
+declare const columns: ({
+    name: string;
+    displayName: string;
+    valueGetter: (user: any) => any;
+    align?: undefined;
+    cellRenderer?: undefined;
+} | {
+    name: string;
+    displayName: string;
+    valueGetter?: undefined;
+    align?: undefined;
+    cellRenderer?: undefined;
+} | {
+    name: string;
+    displayName: string;
+    align: string;
+    cellRenderer: () => import("react/jsx-runtime").JSX.Element;
+    valueGetter?: undefined;
+})[];
+declare const data: {
+    username: string;
+    displayName: string;
+    email: string;
+    createdAt: Date;
+}[];

package/dist/src/components/common/Table/TablePagination.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+
+interface TablePaginationProps {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+}
+declare const TablePagination: FC<TablePaginationProps>;
+export default TablePagination;

package/dist/src/components/common/Table/generatePagination.d.ts

@@ -0,0 +1 @@
+export declare const generatePagination: (totalPages: number, page: number, surroundingPages?: number) => string[];

package/dist/src/components/common/Table/table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/common/Tabs/Tabs.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+
+interface TabsProps {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+    children: React.ReactNode;
+}
+interface TabsListProps {
+    className?: string;
+    children: React.ReactNode;
+}
+interface TabsTriggerProps {
+    value: string;
+    disabled?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+interface TabsContentProps {
+    value: string;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare const Tabs: React.FC<TabsProps>;
+export declare const TabsList: React.FC<TabsListProps>;
+export declare const TabsTrigger: React.FC<TabsTriggerProps>;
+export declare const TabsContent: React.FC<TabsContentProps>;
+export {};

package/dist/src/components/common/TextArea/TextArea.d.ts

@@ -0,0 +1,6 @@
+import { default as React, DetailedHTMLProps } from 'react';
+
+export interface TextAreaProps extends DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> {
+}
+export declare const TextArea: React.ForwardRefExoticComponent<Omit<TextAreaProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export default TextArea;

package/dist/src/components/common/TextArea/TextArea.stories.d.ts

@@ -0,0 +1,17 @@
+import { default as TextArea } from './TextArea';
+declare namespace _default {
+    export let title: string;
+    export { TextArea as component };
+    export namespace parameters {
+        let layout: string;
+    }
+    export let tags: string[];
+    export namespace args {
+        let placeholder: string;
+    }
+}
+export default _default;
+export const Default: {};
+export namespace WithLabel {
+    function render(args: any): import("react/jsx-runtime").JSX.Element;
+}

package/dist/src/components/common/Tooltip/Tooltip.d.ts

@@ -0,0 +1,15 @@
+import { FC, ReactNode } from 'react';
+
+export interface TooltipProps {
+    open?: boolean;
+    children: ReactNode;
+    displayName?: string;
+    tooltipContent?: ReactNode;
+    delayDuration?: number;
+    disabled?: boolean;
+    side?: "right" | "top" | "bottom" | "left";
+    sideOffset?: number;
+    className?: string;
+}
+export declare const Tooltip: FC<TooltipProps>;
+export default Tooltip;

package/dist/src/components/common/Tooltip/Tooltip.stories.d.ts

@@ -0,0 +1,35 @@
+import { default as Tooltip } from './Tooltip';
+declare namespace _default {
+    export let title: string;
+    export { Tooltip as component };
+    export namespace parameters {
+        let layout: string;
+    }
+    export let tags: string[];
+    export namespace argTypes {
+        namespace children {
+            let control: boolean;
+        }
+        namespace tooltipContent {
+            let control_1: boolean;
+            export { control_1 as control };
+        }
+    }
+}
+export default _default;
+export namespace SimpleContent {
+    namespace args {
+        export let displayName: string;
+        let children_1: import("react/jsx-runtime").JSX.Element;
+        export { children_1 as children };
+    }
+}
+export namespace ComplexContent {
+    export namespace args_1 {
+        let children_2: import("react/jsx-runtime").JSX.Element;
+        export { children_2 as children };
+        let tooltipContent_1: import("react/jsx-runtime").JSX.Element;
+        export { tooltipContent_1 as tooltipContent };
+    }
+    export { args_1 as args };
+}

package/dist/src/components/common/index.d.ts

@@ -0,0 +1,58 @@
+export { Button } from './Button/Button';
+export type { ButtonProps } from './Button/Button';
+export { Badge, type BadgeProps } from './Badge/Badge';
+export { Badges, type BadgesProps } from './Badge/Badges';
+export * from './CopyToClipboardButton/CopyToClipboardButton';
+export { FieldGroup } from './FieldGroup/FieldGroup';
+export type { FieldGroupProps } from './FieldGroup/FieldGroup';
+export { Input } from './Input/Input';
+export type { InputProps } from './Input/Input';
+export { InputError } from './InputError/InputError';
+export type { InputErrorProps } from './InputError/InputError';
+export { Label } from './Label/Label';
+export type { LabelProps } from './Label/Label';
+export { default as Select } from './Select/Select';
+export type { SelectProps } from './Select/Select';
+export { TextArea } from './TextArea/TextArea';
+export type { TextAreaProps } from './TextArea/TextArea';
+export { SearchInput } from './SearchInput/SearchInput';
+export type { SearchInputProps } from './SearchInput/SearchInput';
+export { SearchAutocomplete } from './SearchAutocomplete/SearchAutocomplete';
+export type { SearchAutocompleteProps } from './SearchAutocomplete/SearchAutocomplete';
+export type { Suggestion } from './SearchAutocomplete/types';
+export { default as Show } from './Show/Show';
+export { Skeleton } from './Skeleton/Skeleton';
+export { SkeletonList } from './Skeleton/SkeletonList';
+export type { SkeletonProps } from './Skeleton/Skeleton';
+export type { SkeletonListProps } from './Skeleton/SkeletonList';
+export { DropdownList } from './DropdownList/DropdownList';
+export { styles as dropdownListStyles } from './DropdownList';
+export type { DropdownListProps } from './DropdownList/DropdownList';
+export { Tooltip } from './Tooltip/Tooltip';
+export type { TooltipProps } from './Tooltip/Tooltip';
+export { Spinner } from './Spinner/Spinner';
+export type { SpinnerProps } from './Spinner/Spinner';
+export { Switch } from './Switch/Switch';
+export type { SwitchProps } from './Switch/Switch';
+export * from './Tabs/Tabs';
+export { default as EyeIcon } from './Icon/EyeIcon';
+export * from './Icon/ClipboardIcon';
+export * from './Icon/ClipboardCheckIcon';
+export { default as PasswordInput } from './PasswordInput/PasswordInput';
+export { default as Dialog } from './Dialog';
+export * from './Dialog';
+export { default as Pill } from './Pill/Pill';
+export type { PillProps } from './Pill/Pill';
+export { default as ConfirmDialog } from './ConfirmDialog/ConfirmDialog';
+export type { ConfirmDialogProps } from './ConfirmDialog/ConfirmDialog';
+export { default as ErrorState } from './ErrorState';
+export * from './ErrorState';
+export { default as List } from './List';
+export * from './List';
+export * from './Pagination/Pagination';
+export { default as PluralizeCounter } from './PluralizeCounter/PluralizeCounter';
+export { default as Table } from './Table/Table';
+export * from './Table/Table';
+export { default as EmptyState } from './EmptyState/EmptyState';
+export { default as Alert } from './Alert';
+export * from './Alert';

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

@@ -0,0 +1,6 @@
+export { ModulePlaceHolder } from './ModulePlaceHolder';
+export { ExtendExtensionPoint } from './ExtendExtensionPoint';
+export { ExtensionPoint } from './ExtensionPoint';
+export { default as Authorized } from './Authorized';
+export { default as PlatformEventListener } from './PlatformEventListener';
+export { default as ApplicationIcon } from './ApplicationIcon';

package/dist/src/constants/index.d.ts

@@ -0,0 +1,5 @@
+export declare const PAE_GLOBAL_STATE_KEY = "__PAE_GLOBAL_STATE__";
+export declare const GLOBAL_REACTIVE_STATE_KEY = "__PAE_REACTIVE_GLOBAL_STATE__";
+export declare const EXTENSION_POINTS_REGISTRY = "__PAE_EXTENSIONS_POINTS_REGISTRY__";
+export declare const PAE_CUSTOMIZATIONS_LOADING_STATE_KEY = "__PAE_CUSTOMIZATIONS_LOADING_STATE_KEY__";
+export declare const LOGOUT_URL = "/auth/logout";

package/dist/src/core/PlatformEvents.d.ts

@@ -0,0 +1,13 @@
+declare const PlatformEvents: {
+    auth: {
+        SESSION_EXPIRED: string;
+    };
+    apps: {
+        APP_CLICKED: string;
+    };
+    shell: {
+        NAVBAR_STATE_CHANGED: string;
+        MENU_STATE_CHANGED: string;
+    };
+};
+export default PlatformEvents;

package/dist/src/core/gateway/GatewayHttpHeaders.d.ts

@@ -0,0 +1,10 @@
+declare const GatewayHttpHeaders: {
+    /**
+     * When sent as part of a request to the gateway it won't return a redirect if the the token / session is
+     * expired or invalid. It will return a 401 instead.
+     * Otherwise by default it redirects to the login (useful for browsers requests)
+     */
+    NO_AUTH_REDIRECT: string;
+    TENANT: string;
+};
+export default GatewayHttpHeaders;

package/dist/src/core/index.d.ts

@@ -0,0 +1 @@
+export { default as PlatformEvents } from './PlatformEvents';

package/dist/src/getGlobalState.d.ts

@@ -0,0 +1 @@
+export declare function getGlobalState(): import('./types').PAEState;

package/dist/src/hocs/authorized.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+export declare const authorized: <T extends object>(WrappedComponent: React.ComponentType<T>, operations: string[]) => React.FC<T>;
+export default authorized;

package/dist/src/hocs/extensionPoint.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+
+/**
+ * A HOC to make its wrapped component extensible by other microfrontend modules.
+ * If there is an extension then it will use that one instead of the wrapped component.
+ *
+ * This is one of the ways to declare and use extension points.
+ * Suitable to declare a whole React component as extensible.
+ *
+ * There might be other forms in case the value of the extension point is not intended to be a React Components
+ * but some other data type (such as styles ?, colors ?)
+ *
+ * Under the hood this is a HOC over <ExtensionPoint> component.
+ * Another way to use it in case you want to wrap a component.
+ */
+export declare const extensionPoint: <T extends object>(WrappedComponent: React.ComponentType<T>, extensionPointName?: string) => React.FC<T>;
+export default extensionPoint;

package/dist/src/hocs/index.d.ts

@@ -0,0 +1,2 @@
+export { extensionPoint } from './extensionPoint';
+export { authorized } from './authorized';

package/dist/src/hooks/applications/ApplicationMenu.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+
+export type AplicationMenuSubItem = {
+    label: string;
+    path?: string;
+    Icon?: React.ReactNode;
+    operations?: string[];
+};
+export type ApplicationMenuItem = {
+    label: string;
+    path?: string;
+    Icon?: React.ReactNode;
+    align?: 'top' | 'bottom';
+    operations?: string[];
+    items?: AplicationMenuSubItem[];
+    canCollapse?: boolean;
+};
+export type ApplicationMenu = ApplicationMenuItem[];

package/dist/src/hooks/applications/PlatformApplication.d.ts

@@ -0,0 +1,10 @@
+import { ModuleMetadata, Operation, Role } from '@bluealba/pae-core';
+
+export type PlatformApplication = {
+    name: string;
+    displayName?: string;
+    route?: string;
+    modules: ModuleMetadata[];
+    operations: Operation[];
+    roles: Role[];
+};

package/dist/src/hooks/applications/useApplicationIcon.d.ts

@@ -0,0 +1,4 @@
+import { PlatformApplication } from './PlatformApplication';
+
+export declare const useApplicationIcon: (application: PlatformApplication | string) => any;
+export default useApplicationIcon;

package/dist/src/hooks/applications/useApplicationJSModule.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the JS Module of a given PAE Module by name.
+ * This does the System import of the module.
+ * Low-level architectural stuff on top of single-spa architecture.
+ * Used by other framework generic hooks to work with PAE modules by convention.
+ *
+ * Implements in-memory caching with version-based invalidation:
+ * - Modules are cached during the session (cleared on page refresh)
+ * - Cache key includes module version for automatic invalidation
+ * - When module version changes, cache is automatically invalidated
+ */
+export declare const useApplicationJSModule: (moduleName?: string) => System.Module | null;
+/**
+ * Clear the module cache (useful for debugging and testing)
+ * Can clear all modules or a specific module by name
+ */
+export declare const clearModuleCache: (moduleName?: string) => void;
+export default useApplicationJSModule;

package/dist/src/hooks/applications/useApplicationMenu.d.ts

@@ -0,0 +1,11 @@
+import { ApplicationMenu } from './ApplicationMenu';
+import { PlatformApplication } from './PlatformApplication';
+import { Operation } from '@bluealba/pae-core';
+
+type UseApplicationMenuReturnType = {
+    loading: boolean;
+    menu: ApplicationMenu;
+};
+export declare const useApplicationMenu: (application: PlatformApplication | undefined) => UseApplicationMenuReturnType;
+export default useApplicationMenu;
+export declare const hasAccess: (authorizedOperations: Operation[]) => (operations: string[]) => boolean;

package/dist/src/hooks/applications/useApplicationUIModule.d.ts

@@ -0,0 +1,4 @@
+import { PlatformApplication } from './PlatformApplication';
+
+export declare const useApplicationUIModule: (application: PlatformApplication | undefined) => import('@bluealba/pae-core').ModuleMetadata | undefined;
+export default useApplicationUIModule;

package/dist/src/hooks/applications/useApplications.d.ts

@@ -0,0 +1,4 @@
+import { PlatformApplication } from './PlatformApplication';
+
+export declare const useApplications: () => PlatformApplication[];
+export default useApplications;

package/dist/src/hooks/applications/useCurrentApplication.d.ts

@@ -0,0 +1,8 @@
+import { PlatformApplication } from './PlatformApplication';
+
+/**
+ * Gives access to the currently active PAE application based on the current browser's path.
+ */
+export declare const useCurrentApplication: () => PlatformApplication | undefined;
+export declare const findApplicationMatchingPath: (path: string, applications: PlatformApplication[]) => PlatformApplication | undefined;
+export default useCurrentApplication;

package/dist/src/hooks/applications/useCurrentApplication.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/applications/useCurrentApplicationName.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the current active PAE application name based on the browser's route.
+ * Or null if there is none.
+ */
+export declare const useCurrentApplicationName: () => string | undefined;
+export default useCurrentApplicationName;

package/dist/src/hooks/applications/useCurrentJSModule.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gives access to the JS module of the current UI module. This is the JS exported objects.
+ * Low-level stuff used by the framework.
+ * We use this in cases where a generic module like pae-shell needs to collaborate with a convention
+ * over UI modules that export stuff such as icons, or the menu definition.
+ * Then the generic shell can render a consistent UI based on the current JS module
+ */
+export declare const useCurrentJSModule: () => System.Module | null;
+export default useCurrentJSModule;

package/dist/src/hooks/catalog/useCatalog.d.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata } from '@bluealba/pae-core';
+
+/**
+ * Provides access to the PAE Applications Catalog object.
+ * NOTE: in the future we might handle server-side updates of the catalog
+ * by reacting with changes.
+ *
+ * REVIEWME: we are handling a copy of the catalog for every usage of `useCatalog`
+ * We should instead see if we can reuse a single source of truth, like a context.
+ * The problem is that every MF has its own DOM (React.renderRoot()) and context are not inherited.
+ * Maybe we should do the same approach as we did for the <PAEModule> and its ModuleContext.
+ * At least 1 copy per application.
+ */
+export declare const useCatalog: () => ModuleMetadata[];

package/dist/src/hooks/catalog/useMutableCatalog.d.ts

@@ -0,0 +1,28 @@
+import { ModuleMetadata, ModuleProps } from '@bluealba/pae-core';
+import { SetOrUpdateParam } from '../../utils/immutable';
+
+export type SetCatalogParam = SetOrUpdateParam<ModuleMetadata[]>;
+export type SetModulePropsParam = SetOrUpdateParam<ModuleProps>;
+export type UseMutableCatalogReturnType = [
+    ModuleMetadata[],
+    (valueOrFn: SetCatalogParam) => void,
+    (moduleName: string, valueOrFn: SetOrUpdateParam<ModuleProps>) => void
+];
+/**
+ * Gives access to the catalog (modules) allowing to reactively mutate it.
+ * Returns the current value and fn's to update it.
+ * Usage:
+ *
+ *   const [catalog, setCatalog, setModuleProps] = useMutableCatalog()
+ *
+ *   // ... later in a callback
+ *   setCatalog(newValue) // or ...
+ *   setCatalog(prev => { ...prev, ...changes })
+ *
+ *   // or just update one module
+ *   setModuleProps("my-module", newProps) // or ...
+ *   setModuleProps("my-module", prev => ({ ...prev, ...changes }))
+ *
+ */
+export declare const useMutableCatalog: () => UseMutableCatalogReturnType;
+export default useMutableCatalog;

package/dist/src/hooks/catalog/userCatalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/commons/useObservable.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+
+/**
+ * Given an Observable object it gives a reactive value for React.
+ * Subscribes to changes to the observable. Basic, but avoids repeating code
+ */
+export declare const useObservable: <T>(observable: Observable<T>, initialValue: T) => T;
+export default useObservable;

package/dist/src/hooks/commons/useResource.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A generic hook to work with a REST resources.
+ * If you comply with the REST spec for normal operations such as create, update, delete, read will be inferred
+ * automatically
+ */
+export declare const useResource: <T>(path: string, resourceName: string) => {
+    useCreate: (options?: import('./useResourceActions').MutationFeedbackOptions<T> | undefined) => import('@tanstack/react-query').UseMutationResult<T, Error, any, unknown>;
+    useReadQuery: (opts?: import('./useResourceActions').QueryOptions) => import('@tanstack/react-query').UseQueryResult<T[], Error>;
+    useReadByIdQuery: (id: string, opts?: import('./useResourceActions').QueryOptions) => import('@tanstack/react-query').UseQueryResult<import('@tanstack/query-core').NoInfer<T>, Error>;
+    useUpdate: (options?: import('./useResourceActions').MutationFeedbackOptions<T> | undefined) => import('@tanstack/react-query').UseMutationResult<T, Error, {
+        id: string;
+        data: any;
+    }, unknown>;
+    usePartialUpdate: (options?: import('./useResourceActions').MutationFeedbackOptions<T> | undefined) => import('@tanstack/react-query').UseMutationResult<T, Error, {
+        id: string;
+        data: any;
+    }, unknown> | undefined;
+    useDelete: (options?: import('./useResourceActions').MutationFeedbackOptions<T> | undefined) => import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+    invalidateQueries: () => void;
+};
+export default useResource;

package/dist/src/hooks/commons/useResourceActions.d.ts

@@ -0,0 +1,56 @@
+import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Type definitions for CRUD operations
+ */
+export interface CrudOperations<T = any, TCreate = any, TUpdate = any, TPartialUpdate = any> {
+    createFn: (data: TCreate) => Promise<T>;
+    readFn: () => Promise<T[]>;
+    readByIdFn: (id: string) => Promise<T>;
+    updateFn: (id: string, data: TUpdate) => Promise<T>;
+    partialUpdateFn?: (id: string, data: TPartialUpdate) => Promise<T>;
+    deleteFn: (id: string) => Promise<void>;
+}
+export interface ResourceActions<T = any, TCreate = any, TUpdate = any, TPartialUpdate = any> {
+    create: UseMutationResult<T, Error, TCreate, unknown>;
+    useReadQuery: () => UseQueryResult<T[], Error>;
+    useReadByIdQuery: (id: string) => UseQueryResult<T, Error>;
+    update: UseMutationResult<T, Error, {
+        id: string;
+        data: TUpdate;
+    }, unknown>;
+    partialUpdate: UseMutationResult<T, Error, {
+        id: string;
+        data: TPartialUpdate;
+    }, unknown>;
+    delete: UseMutationResult<void, Error, string, unknown>;
+}
+export interface QueryOptions {
+    enabled?: boolean;
+}
+export interface MutationFeedbackOptions<T> {
+    overrideSuccessMessage?: (resourceName: string, data?: T | null) => string;
+    overrideErrorMessage?: (resourceName: string, error?: Error) => string;
+}
+/**
+ * Hook to create standardized CRUD actions for a resource
+ *
+ * @param resourceKey - Unique identifier for the resource (used in query keys and notifications)
+ * @param operations - Object containing CRUD operation functions
+ * @returns Object with create, read, readById, update, and delete operations
+ */
+export declare const useResourceActions: <T = any, TCreate = any, TUpdate = any, TPartialUpdate = any>(resourceKey: string, resourceName: string, operations: CrudOperations<T, TCreate, TUpdate, TPartialUpdate>) => {
+    useCreate: (options?: MutationFeedbackOptions<T>) => UseMutationResult<T, Error, TCreate, unknown>;
+    useReadQuery: (opts?: QueryOptions) => UseQueryResult<T[], Error>;
+    useReadByIdQuery: (id: string, opts?: QueryOptions) => UseQueryResult<import('@tanstack/react-query').NoInfer<T>, Error>;
+    useUpdate: (options?: MutationFeedbackOptions<T>) => UseMutationResult<T, Error, {
+        id: string;
+        data: TUpdate;
+    }, unknown>;
+    usePartialUpdate: (options?: MutationFeedbackOptions<T>) => UseMutationResult<T, Error, {
+        id: string;
+        data: TPartialUpdate;
+    }, unknown> | undefined;
+    useDelete: (options?: MutationFeedbackOptions<T>) => UseMutationResult<void, Error, string, unknown>;
+    invalidateQueries: () => void;
+};

package/dist/src/hooks/commons/useSubjectObservable.d.ts

@@ -0,0 +1,11 @@
+import { Subject } from 'rxjs';
+import { SetOrUpdateFn } from '../../utils/immutable';
+
+/**
+ * Hook to work reactively with Subject's (which are mutable Observables)
+ * This would be the mutable version of useObservable.
+ * Of course everything is pure here so when we say "mutable" we actually mean that it provides
+ * a pure way to change the value (doesn't actually mutate it but creates a new value and triggers reactivity)
+ */
+export declare const useSubjectObservable: <T>(subject: Subject<T>, initialValue: T) => [T, SetOrUpdateFn<T>];
+export default useSubjectObservable;

package/dist/src/hooks/customizations/useDynamicFonts.d.ts

@@ -0,0 +1,13 @@
+type FontVariant = {
+    path: string;
+    fontWeight: string;
+    format?: string;
+};
+export type FontDefinition = {
+    fontFamily: string;
+    variants: FontVariant[];
+};
+export declare function useDynamicFonts(fonts?: FontDefinition[]): {
+    fontsLoaded: boolean;
+};
+export {};