fluxo-ui 0.0.1

package/src/components/tab-view/TabView.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { TabPage } from './TabPage';
+export interface TabChangeEvent {
+    originalEvent: React.MouseEvent | React.KeyboardEvent | null;
+    index: number;
+    tab: React.ReactElement;
+}
+export interface TabCloseEvent {
+    index: number;
+    tab: React.ReactElement;
+}
+export type TabViewVariant = 'default' | 'pills' | 'enclosed' | 'segment' | 'editor' | 'thick-border' | 'elevated';
+export interface TabViewProps {
+    activeIndex?: number;
+    onTabChange?: (e: TabChangeEvent) => void;
+    onBeforeTabChange?: (e: TabChangeEvent) => boolean | Promise<boolean>;
+    onTabClose?: (e: TabCloseEvent) => void;
+    headerEnd?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    scrollable?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    variant?: TabViewVariant;
+    preMount?: boolean;
+    children?: React.ReactNode;
+}
+export declare const TabView: React.FC<TabViewProps>;
+export { TabPage };

package/src/components/tab-view/index.d.ts

@@ -0,0 +1,4 @@
+export { TabPage } from './TabPage';
+export type { TabPageProps } from './TabPage';
+export { TabView } from './TabView';
+export type { TabChangeEvent, TabCloseEvent, TabViewProps, TabViewVariant } from './TabView';

package/src/components/tab-view/tabview-utils.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare const calculateScrollPosition: (container: HTMLElement, targetElement: HTMLElement) => number;
+export declare const getVisibleTabs: (children: React.ReactNode) => React.ReactElement[];
+export declare const isTabDisabled: (tab: React.ReactElement) => boolean;
+export declare const renderIcon: (icon: string | React.ComponentType<any> | React.ReactElement | undefined, className?: string) => React.ReactNode;

package/src/components/table/Table.d.ts

@@ -0,0 +1,35 @@
+import { Column, OnChangeParams } from './table-types';
+declare function Table({ id, isLoading, expectedRows, columns, rows, totalRows, page, sortColumn: colToSort, sortAsc: isAsc, onSort, onChange, noRowsMessage, rowsPerPage, rowCounts, pagination, containerClassName, onRowClick, bordered, striped, compact, comfortable, borderless, hoverable, cardStyle, minimalHeader, stickyHeader, }: TableProps): import("react/jsx-runtime").JSX.Element;
+export default Table;
+export type TableProps = {
+    id?: string;
+    isLoading?: boolean;
+    expectedRows?: number;
+    columns: Column[];
+    rows: any[];
+    totalRows: number;
+    onSort?: (column: Column, asc: boolean) => void;
+    onChange?: (params: OnChangeParams) => void;
+    noRowsMessage?: string;
+    rowCounts?: number[];
+    rowsPerPage?: number;
+    sortColumn?: Column;
+    sortAsc?: boolean;
+    page?: number;
+    pagination?: boolean;
+    containerClassName?: string;
+    onRowClick?: (arg: {
+        row: any;
+        index: number;
+        event: any;
+    }) => void;
+    bordered?: boolean;
+    striped?: boolean;
+    compact?: boolean;
+    comfortable?: boolean;
+    borderless?: boolean;
+    hoverable?: boolean;
+    cardStyle?: boolean;
+    minimalHeader?: boolean;
+    stickyHeader?: boolean;
+};

package/src/components/table/TableBody.d.ts

@@ -0,0 +1,13 @@
+import { Column } from './table-types';
+type TableBodyProps = {
+    columns: Column[];
+    rows: any[];
+    noRowsMessage?: string;
+    onRowClick?: (arg: {
+        row: any;
+        index: number;
+        event: any;
+    }) => void;
+};
+declare const TableBody: ({ columns, rows, noRowsMessage, onRowClick }: TableBodyProps) => import("react/jsx-runtime").JSX.Element;
+export default TableBody;

package/src/components/table/TableFooter.d.ts

@@ -0,0 +1,12 @@
+import { Column } from './table-types';
+type TableFooterProps = {
+    columns: Column[];
+    rowsCount: number;
+    onChangeCount: any;
+    rowsCounts: number[];
+    pageIndex: number;
+    totalPages: number;
+    onNavigate: any;
+};
+declare function TableFooter({ columns, rowsCount: count, pageIndex: currentPage, totalPages, rowsCounts, onChangeCount, onNavigate: goToPage, }: TableFooterProps): import("react/jsx-runtime").JSX.Element;
+export default TableFooter;

package/src/components/table/TableHeader.d.ts

@@ -0,0 +1,9 @@
+import { Column } from './table-types';
+type TableHeaderProps = {
+    columns: Column[];
+    sortColumn?: Column;
+    sortAsc: boolean;
+    onSort?: any;
+};
+declare const TableHeader: ({ columns, sortColumn, sortAsc, onSort }: TableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default TableHeader;

package/src/components/table/table-types.d.ts

@@ -0,0 +1,16 @@
+export type Column = {
+    title: string;
+    field: string;
+    helpText?: string;
+    headerClassName?: string;
+    cellClassName?: string;
+    sortable?: boolean;
+    hideBelow?: 'xs' | 'sm' | 'md' | 'mlg' | 'lg' | 'xl' | '2xl' | '3xl';
+    template?: (row: any) => React.ReactNode;
+};
+export type OnChangeParams = {
+    sortColumn?: Column;
+    sortAsc?: boolean;
+    count: number;
+    pageNumber: number;
+};

package/src/components/table/useSortedData.d.ts

@@ -0,0 +1,2 @@
+declare function useSortedData<T>(rows: T[], field: string, isAsc: boolean | undefined, enabled: boolean): T[];
+export default useSortedData;

package/src/components/timeline/Timeline.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+type TimelineColor = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+type TimelineLayout = 'vertical' | 'horizontal';
+type TimelineAlign = 'left' | 'right' | 'alternate';
+type TimelineConnectorStyle = 'solid' | 'dashed' | 'dotted';
+type TimelineMarkerSize = 'sm' | 'md' | 'lg';
+interface TimelineEvent {
+    id: string;
+    title: string;
+    description?: React.ReactNode;
+    timestamp?: string;
+    icon?: React.ReactNode;
+    color?: TimelineColor;
+    marker?: React.ReactNode;
+    content?: React.ReactNode;
+}
+interface TimelineProps {
+    events: TimelineEvent[];
+    layout?: TimelineLayout;
+    align?: TimelineAlign;
+    connectorStyle?: TimelineConnectorStyle;
+    className?: string;
+    markerSize?: TimelineMarkerSize;
+}
+declare function Timeline({ events, layout, align, connectorStyle, className, markerSize, }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+export { Timeline };
+export type { TimelineEvent, TimelineProps, TimelineColor, TimelineLayout, TimelineAlign, TimelineConnectorStyle, TimelineMarkerSize, };

package/src/components/timeline/TimelineItem.d.ts

@@ -0,0 +1,11 @@
+import { TimelineAlign, TimelineEvent, TimelineLayout } from './Timeline';
+interface TimelineItemProps {
+    event: TimelineEvent;
+    index: number;
+    isFirst: boolean;
+    isLast: boolean;
+    align: TimelineAlign;
+    layout: TimelineLayout;
+}
+declare function TimelineItem({ event, index, isFirst, isLast, align, layout }: TimelineItemProps): import("react/jsx-runtime").JSX.Element;
+export default TimelineItem;

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

@@ -0,0 +1,2 @@
+export { Timeline } from './Timeline';
+export type { TimelineEvent, TimelineProps, TimelineColor, TimelineLayout, TimelineAlign, TimelineConnectorStyle, TimelineMarkerSize, } from './Timeline';

package/src/components/tooltip/Tooltip.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { PlacementCorners } from '../../types';
+export interface TooltipOptions {
+    timeout?: number;
+    content?: React.ReactNode | string;
+    placement?: PlacementCorners;
+}
+export interface TooltipData {
+    event: React.MouseEvent;
+    options: TooltipOptions;
+}
+export declare function registerTooltipHandlers(show: (data: TooltipData) => void, hide: (timeout: number) => void): void;
+export declare function unregisterTooltipHandlers(show: (data: TooltipData) => void, hide: (timeout: number) => void): void;
+export declare function showTooltip(e: React.MouseEvent, opt: TooltipOptions | React.ReactNode | string): void;
+export declare function hideTooltip(params?: {
+    timeout?: number;
+}): void;

package/src/components/tooltip/TooltipManager.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare function TooltipProvider(): React.ReactPortal | null;
+export default TooltipProvider;

package/src/components/tooltip/utils.d.ts

@@ -0,0 +1,6 @@
+import { PlacementCorners } from '../../types';
+export declare function computeTooltipPosition(targetRect: DOMRect, tooltipRect: DOMRect, preferredPlacement?: PlacementCorners): {
+    top: number;
+    left: number;
+    placement: PlacementCorners;
+};

package/src/components/tour/StepTour.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { TourStep } from './types';
+interface StepTourProps {
+    steps: TourStep[];
+    isOpen: boolean;
+    onClose: () => void;
+    initialStep?: number;
+    zIndex?: number;
+    className?: string;
+}
+declare function StepTour({ steps, isOpen, onClose, initialStep, zIndex }: StepTourProps): React.ReactPortal | null;
+export default StepTour;
+interface BackdropProps {
+    visible: boolean;
+    highlightRect: DOMRect | null;
+    zIndex?: number;
+}
+export declare const Backdrop: React.FC<BackdropProps>;

package/src/components/tour/TourTooltip.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Placement } from './types';
+export interface TourTooltipProps {
+    step: {
+        title?: React.ReactNode;
+        content: React.ReactNode;
+        placement?: Placement;
+        selector: string;
+    };
+    targetRect: DOMRect;
+    onNext: () => void;
+    onPrev: () => void;
+    onSkip: () => void;
+    index: number;
+    total: number;
+    zIndex?: number;
+}
+export declare function TourTooltip({ step, targetRect, onNext, onPrev, onSkip, index, total, zIndex }: TourTooltipProps): import("react/jsx-runtime").JSX.Element;

package/src/components/tour/types.d.ts

@@ -0,0 +1,12 @@
+export type Placement = 'top' | 'bottom' | 'left' | 'right';
+export interface TourStep {
+    selector: string;
+    title?: React.ReactNode;
+    content: React.ReactNode;
+    placement?: Placement;
+    order?: number;
+    id?: string | number;
+    onNext?(): void;
+    onPrev?(): void;
+    onSkip?(): void;
+}

package/src/components/tour/useWindowResize.d.ts

@@ -0,0 +1,4 @@
+export declare function useWindowResize(): {
+    width: number;
+    height: number;
+};

package/src/components/tour/utils.d.ts

@@ -0,0 +1,10 @@
+import { Placement } from './types';
+export declare function isElementInViewport(el: HTMLElement | null): boolean;
+export declare function computeTooltipPosition(targetRect: DOMRect, tooltipSize: {
+    width: number;
+    height: number;
+}, placement?: Placement, containerRect?: DOMRect): {
+    top: number;
+    left: number;
+    placement: Placement;
+};

package/src/components/tree-view/TreeNodeComponent.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TreeNodeProps } from './tree-view-types';
+declare const _default: React.NamedExoticComponent<TreeNodeProps>;
+export default _default;

package/src/components/tree-view/TreeView.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TreeViewProps } from './tree-view-types';
+declare const TreeView: React.FC<TreeViewProps>;
+export default TreeView;

package/src/components/tree-view/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TreeView } from './TreeView';
+export type { CheckState, DragDropInfo, TreeNode, TreeNodeProps, TreeViewProps } from './tree-view-types';

package/src/components/tree-view/tree-view-types.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+export interface TreeNode {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    children?: TreeNode[];
+    isLeaf?: boolean;
+    disabled?: boolean;
+    data?: Record<string, unknown>;
+}
+export interface DragDropInfo {
+    dragNode: TreeNode;
+    dropNode: TreeNode;
+    dropPosition: 'before' | 'inside' | 'after';
+}
+export interface TreeViewProps {
+    nodes: TreeNode[];
+    expandedKeys?: Set<string>;
+    selectedKeys?: Set<string>;
+    checkedKeys?: Set<string>;
+    defaultExpandedKeys?: Set<string>;
+    selectionMode?: 'single' | 'multiple' | 'none';
+    checkboxes?: boolean;
+    draggable?: boolean;
+    loadChildren?: (node: TreeNode) => Promise<TreeNode[]>;
+    onExpand?: (keys: Set<string>, node: TreeNode) => void;
+    onSelect?: (keys: Set<string>, node: TreeNode) => void;
+    onCheck?: (keys: Set<string>, node: TreeNode) => void;
+    onDragDrop?: (info: DragDropInfo) => void;
+    className?: string;
+    nodeTemplate?: (node: TreeNode) => React.ReactNode;
+    filterText?: string;
+}
+export type CheckState = 'checked' | 'unchecked' | 'indeterminate';
+export interface TreeNodeProps {
+    node: TreeNode;
+    level: number;
+    expanded: boolean;
+    selected: boolean;
+    checkState: CheckState;
+    checkboxes: boolean;
+    draggable: boolean;
+    loading: boolean;
+    focused: boolean;
+    dropPosition: 'before' | 'inside' | 'after' | null;
+    nodeTemplate?: (node: TreeNode) => React.ReactNode;
+    onToggle: (node: TreeNode) => void;
+    onSelect: (node: TreeNode, event: React.MouseEvent | React.KeyboardEvent) => void;
+    onCheck: (node: TreeNode) => void;
+    onDragStart: (node: TreeNode, event: React.DragEvent) => void;
+    onDragOver: (node: TreeNode, event: React.DragEvent) => void;
+    onDragLeave: (event: React.DragEvent) => void;
+    onDrop: (node: TreeNode, event: React.DragEvent) => void;
+    onDragEnd: (event: React.DragEvent) => void;
+}

package/src/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useClickOutside } from './useClickOutside';
+export { useDebounce } from './useDebounce';
+export { useKeyboard } from './useKeyboard';
+export { useMobile } from './useMobile';
+export { usePosition } from './usePosition';

package/src/hooks/useClickOutside.d.ts

@@ -0,0 +1 @@
+export declare const useClickOutside: (ref: React.RefObject<HTMLElement | null>, callback: (e: MouseEvent) => void, enabled?: boolean) => void;

package/src/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: <T>(value: T, delay: number) => T;

package/src/hooks/useKeyboard.d.ts

@@ -0,0 +1 @@
+export declare const useKeyboard: (handlers: Record<string, () => void>, enabled?: boolean) => void;

package/src/hooks/useMobile.d.ts

@@ -0,0 +1 @@
+export declare const useMobile: () => boolean;

package/src/hooks/usePosition.d.ts

@@ -0,0 +1,8 @@
+export declare const usePosition: () => {
+    position: {
+        top: number;
+        left: number;
+        placement: "top" | "bottom";
+    };
+    calculatePosition: (triggerElement: HTMLElement, popoverElement: HTMLElement) => void;
+};

package/src/plugins/vite/index.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+interface EtherUiSourcePluginOptions {
+    sourcePath?: string;
+    useSource?: boolean;
+}
+declare function etherUiSource(options?: EtherUiSourcePluginOptions): Plugin;
+export { etherUiSource };
+export type { EtherUiSourcePluginOptions };

package/src/services/container.d.ts

@@ -0,0 +1,29 @@
+import { ScopeHandle, ServiceConstructor, ServiceFactory, ServiceLifetime, ServiceOptions, ServiceResolver } from './types';
+export declare class ServiceContainer {
+    private services;
+    private paramServices;
+    private resolver;
+    registerSingleton<T>(type: ServiceConstructor<T>, serviceName: string, shortName: string, opts?: ServiceOptions): this;
+    registerScoped<T>(type: ServiceConstructor<T>, serviceName: string, shortName: string, opts?: ServiceOptions): this;
+    registerTransient<T>(type: ServiceConstructor<T>, serviceName: string, shortName: string, opts?: ServiceOptions): this;
+    registerSingletonFactory<T>(serviceName: string, shortName: string, factory: ServiceFactory<T>, deps?: string[], opts?: ServiceOptions): this;
+    registerScopedFactory<T>(serviceName: string, shortName: string, factory: ServiceFactory<T>, deps?: string[], opts?: ServiceOptions): this;
+    registerTransientFactory<T>(serviceName: string, shortName: string, factory: ServiceFactory<T>, deps?: string[], opts?: ServiceOptions): this;
+    registerParameterized<T, TArgs extends unknown[]>(serviceName: string, shortName: string, lifetime: ServiceLifetime, factory: (resolver: ServiceResolver, ...args: TArgs) => T, opts?: ServiceOptions): this;
+    resolve<T extends Record<string, unknown>>(...serviceNames: string[]): T;
+    resolveScoped<T extends Record<string, unknown>>(...serviceNames: string[]): T;
+    resolveWithArgs<T = unknown>(serviceName: string, ...args: unknown[]): T;
+    createScope(): ScopeHandle;
+    has(name: string): boolean;
+    clearInstances(): void;
+    clearService(name: string): void;
+    private register;
+    private registerFactory;
+    private clearNonRetainedInstances;
+    private getRef;
+    private resolveInternal;
+    private resolveParamInternal;
+    private inject;
+    private validateNoCycles;
+}
+export declare function createContainer(): ServiceContainer;

package/src/services/index.d.ts

@@ -0,0 +1,3 @@
+export { createContainer, ServiceContainer } from './container';
+export { ServiceProvider, ServiceScope, useContainer, useScope, useService, useServiceWithArgs, withServices, } from './react';
+export type { ParameterizedServiceDescriptor, ScopeHandle, ServiceConstructor, ServiceDescriptor, ServiceLifetime, ServiceOptions, ServiceResolver, } from './types';

package/src/services/react.d.ts

@@ -0,0 +1,23 @@
+import { ComponentType, ReactNode } from 'react';
+import { ServiceContainer } from './container';
+import { ScopeHandle } from './types';
+interface ServiceProviderProps {
+    container: ServiceContainer;
+    children: ReactNode;
+    defaultParams?: Record<string, unknown[]>;
+}
+export declare function ServiceProvider({ container, children, defaultParams }: ServiceProviderProps): import("react/jsx-runtime").JSX.Element;
+interface ServiceScopeProps {
+    children: ReactNode;
+}
+export declare function ServiceScope({ children }: ServiceScopeProps): import("react/jsx-runtime").JSX.Element;
+export declare function useService<T extends Record<string, unknown>>(...serviceNames: string[]): T;
+export declare function useServiceWithArgs<T = unknown>(serviceName: string, ...args: unknown[]): T;
+export declare function useScope(): ScopeHandle;
+export declare function useContainer(): ServiceContainer;
+interface WithServicesConfig {
+    services?: string[];
+    parameterized?: Record<string, unknown[]>;
+}
+export declare function withServices<P extends Record<string, unknown>>(Component: ComponentType<P>, config: WithServicesConfig): ComponentType<Omit<P, string>>;
+export {};

package/src/services/types.d.ts

@@ -0,0 +1,36 @@
+export type ServiceLifetime = 'singleton' | 'scoped' | 'transient';
+export interface ServiceConstructor<T = unknown> {
+    new (...args: unknown[]): T;
+    dependencies?: string[];
+}
+export interface ServiceOptions {
+    retain?: boolean;
+}
+export type ServiceFactory<T = unknown> = (resolver: ServiceResolver) => T;
+export interface ServiceDescriptor<T = unknown> {
+    name: string;
+    shortName: string;
+    type?: ServiceConstructor<T>;
+    factory?: ServiceFactory<T>;
+    lifetime: ServiceLifetime;
+    retain: boolean;
+    dependencies?: string[];
+    instance: T | null;
+}
+export interface ParameterizedServiceDescriptor<T = unknown, TArgs extends unknown[] = unknown[]> {
+    name: string;
+    shortName: string;
+    factory: (resolver: ServiceResolver, ...args: TArgs) => T;
+    lifetime: ServiceLifetime;
+    retain: boolean;
+    dependencies?: string[];
+    instances: Map<string, T>;
+}
+export interface ServiceResolver {
+    resolve<T = unknown>(name: string): T;
+}
+export interface ScopeHandle {
+    resolve<T = unknown>(name: string): T;
+    resolveWithArgs<T = unknown>(name: string, ...args: unknown[]): T;
+    dispose(): void;
+}

package/src/store/core/model.d.ts

@@ -0,0 +1,2 @@
+import { ModelConfig, ModelFactory } from '../types';
+export declare function createModel<T extends object | Array<any>>(config: ModelConfig<T>): ModelFactory<T>;

package/src/store/core/state.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, Store } from '../types';
+export declare function create<T extends object | Array<any>>(initializer: () => T, middlewares?: Middleware<T>[]): Store<T>;

package/src/store/factory/react-hooks.d.ts

@@ -0,0 +1,19 @@
+import { ListState, ModelFactory, ModelStore, Store } from '../types';
+type Selector<T, R> = (state: T) => R;
+type EqualityFn<T> = (a: T, b: T) => boolean;
+export declare function createHook<T, S = T>(store: Store<T>): {
+    (): S;
+    <R>(selector: Selector<S, R>, equalityFn?: EqualityFn<R> | boolean): R;
+};
+type ModelStoreState<T> = T & {
+    id: any;
+    isStale: boolean;
+    isLoading: boolean;
+    isSaving: boolean;
+    isDeleting: boolean;
+};
+export declare function createItemHook<T>(modelStore: ModelStore<T>): <R>(selector?: Selector<ModelStoreState<T>, R>, shallowCompare?: boolean) => ModelStoreState<T> | R;
+export declare function createListHook<T>(factory: ModelFactory<T>): <R>(selector?: Selector<ListState<T>, R>, shallowCompare?: boolean) => ListState<T> | R;
+export declare function createModelHook<T>(factory: ModelFactory<T>): <R>(id: any, selector?: Selector<ModelStoreState<T>, R>, shallowCompare?: boolean) => ModelStoreState<T> | R;
+export declare function useDebounce<T>(value: T, delay: number): T;
+export {};

package/src/store/index.d.ts

@@ -0,0 +1,4 @@
+export { createModel } from './core/model';
+export { create } from './core/state';
+export { createHook, createItemHook, createListHook, createModelHook, useDebounce } from './factory/react-hooks';
+export type { AsyncListener, ChangeOptions, ItemLoadBehavior, Listener, ListenerContext, ListState, Middleware, ModelConfig, ModelFactory, ModelStore, PageOptions, PropertyPath, SetStateFunction, Store, Subscription, } from './types';

package/src/store/middlewares/broadcast.d.ts

@@ -0,0 +1,6 @@
+import { Store } from '../types';
+export interface BroadcastMiddlewareOptions {
+    key?: string;
+    filter?: (state: any) => any;
+}
+export declare const broadcastMiddleware: <T>(channelName: string, options?: BroadcastMiddlewareOptions) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/debounce.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const debounceMiddleware: <T>(delay?: number) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/devtools.d.ts

@@ -0,0 +1,4 @@
+import { Store } from '../types';
+export declare const devToolsMiddleware: <T>(store: Store<T>) => Store<T>;
+export declare const persistMiddleware: <T>(storage?: "local" | "session" | Storage, key?: string) => (store: Store<T>) => Store<T>;
+export declare const loggerMiddleware: <T>(predicate?: (state: T, previous?: T) => boolean) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/immer.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const immerMiddleware: <T>(store: Store<T>) => Store<T>;

package/src/store/middlewares/index.d.ts

@@ -0,0 +1,11 @@
+export { broadcastMiddleware } from './broadcast';
+export type { BroadcastMiddlewareOptions } from './broadcast';
+export { debounceMiddleware } from './debounce';
+export { devToolsMiddleware } from './devtools';
+export { immerMiddleware } from './immer';
+export { loggerMiddleware } from './logging';
+export { persistMiddleware } from './persist';
+export { throttleMiddleware } from './throttle';
+export { undoRedoMiddleware } from './undo-redo';
+export type { UndoRedoStore, UndoRedoStateProps } from './undo-redo';
+export { validationMiddleware } from './validation';

package/src/store/middlewares/logging.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const loggerMiddleware: <T>(predicate?: (state: T, previous?: T) => boolean) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/persist.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const persistMiddleware: <T>(storage?: "local" | "session" | Storage, key?: string) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/throttle.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const throttleMiddleware: <T>(delay?: number) => (store: Store<T>) => Store<T>;

package/src/store/middlewares/undo-redo.d.ts

@@ -0,0 +1,13 @@
+import { Store } from '../types';
+export interface UndoRedoStateProps {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export interface UndoRedoStore<T> extends Store<T> {
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    clearHistory: () => void;
+}
+export declare const undoRedoMiddleware: <T>(maxHistorySize?: number) => (store: Store<T>) => UndoRedoStore<T>;

package/src/store/middlewares/validation.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../types';
+export declare const validationMiddleware: <T>(validator: (state: T) => Record<string, string> | undefined, onValidationError?: (errors: Record<string, string>) => void) => (store: Store<T>) => Store<T>;