eze-factory 1.0.0

package/dist/System/Factories/TableFactory.d.ts

@@ -0,0 +1,40 @@
+import { FilterDefinition, QueryComponentMap } from "../Slices/Query/Types";
+import { StatusSliceConfig } from "../Slices/Status/Types";
+import { PaginatorProps } from "../Slices/Paginator/Types";
+import { TableSliceConfig } from "../Slices/Table/Types";
+import { ExporterSliceConfig } from "../Slices/Exporter/Types";
+import { ArrayElement } from "../Slices/Paginator/PaginatorMechanics";
+import { DefaultComponentMap } from "../Constants/QueryDefaults";
+type DefaultMap = typeof DefaultComponentMap;
+type MergedMap<M extends QueryComponentMap> = DefaultMap & M;
+type FactoryQueryConfig<M extends QueryComponentMap> = {
+    componentMap?: M;
+    filters: Record<string, FilterDefinition<MergedMap<M>>>;
+    validators?: any[];
+    onQueryChange?: (query: any) => void;
+    syncWithRouter?: boolean;
+};
+export declare function createTableFactory<P extends {
+    load: (...args: any[]) => Promise<any>;
+    reload: (...args: any[]) => Promise<any>;
+    loadMore: () => Promise<any>;
+    hasMore: boolean;
+    limit: number;
+}, R = Awaited<ReturnType<P["load"]>>, Fmt = undefined, M extends QueryComponentMap = {}>(config: {
+    query?: FactoryQueryConfig<M>;
+    paginator: PaginatorProps<P, R, Fmt, any>;
+    status?: Partial<StatusSliceConfig>;
+    table: TableSliceConfig<ArrayElement<Fmt extends undefined ? R : Fmt>>;
+    exporter?: ExporterSliceConfig<ArrayElement<Fmt extends undefined ? R : Fmt>>;
+}): import("./FactoryPackage").Factory<{
+    status: import("../Slices/Status/Types").StatusAPI<import("../Slices/Status/Types").StatusKit>;
+} & {
+    query: import("../Slices/Query/Types").QueryAPI<MergedMap<M>, Record<string, FilterDefinition<MergedMap<M>>>>;
+} & {
+    paginator: import("../Slices/Paginator/Types").PaginatorAPI<ArrayElement<Fmt extends undefined ? R : Fmt>, any>;
+} & {
+    table: import("../Slices/Table/Types").TableAPI<ArrayElement<Fmt extends undefined ? R : Fmt>>;
+} & {
+    exporter: import("../Slices/Exporter/Types").ExporterAPI;
+}>;
+export {};

package/dist/System/Factories/Types.d.ts

@@ -0,0 +1,25 @@
+import { PaginatorAPI } from "../Slices/Paginator/Types";
+import { StatusAPI } from "../Slices/Status/Types";
+import { IQueryFilterBuilder } from "../Slices/Types";
+import { TableAPI } from "../Slices/Table/Types";
+import { ExporterAPI } from "../Slices/Exporter/Types";
+import { LoaderAPI } from "../Slices/Loader/Types";
+import { QueryAPI } from "../Slices/Query/Types";
+export interface IPaginatorFactory<T> {
+    paginator: PaginatorAPI<T>;
+}
+export interface ILoaderFactory<Response> {
+    loader: LoaderAPI<Response>;
+}
+export interface IStatusFactory {
+    status: StatusAPI;
+}
+export interface IQueryFactory<F extends readonly IQueryFilterBuilder[]> {
+    query: QueryAPI<F>;
+}
+export interface ITableFactory<T> {
+    table: TableAPI<T>;
+}
+export interface IExporterFactory {
+    exporter: ExporterAPI;
+}

package/dist/System/Factories/index.d.ts

@@ -0,0 +1,4 @@
+export { createTableFactory } from "./TableFactory";
+export { createListFactory } from "./ListFactory";
+export { createStaticTableFactory } from "./StaticTableFactory";
+export { createDetailFactory } from "./DetailFactory";

package/dist/System/Slices/Exporter/ExporterMechanics.d.ts

@@ -0,0 +1,17 @@
+import { TableColumnDef } from "../Table/Types";
+import { ExporterDependencies, ExporterSliceConfig } from "./Types";
+export declare const ExporterMechanics: {
+    rowsToCsv: (headers: string[], rows: Record<string, any>[]) => string;
+    rowsToXlsx: (headers: string[], rows: Record<string, any>[]) => Promise<Blob>;
+    saveFileBrowser: (filename: string, blob: Blob) => Promise<void>;
+    saveFileNative: (filename: string, blob: Blob | string) => Promise<void>;
+    resolveData: <TItem>(config: ExporterSliceConfig<TItem>, ctx: ExporterDependencies<TItem>) => Promise<TItem[]>;
+    resolveColumns: <TItem>(config: ExporterSliceConfig<TItem>, ctx: ExporterDependencies<TItem>) => TableColumnDef<TItem>[];
+    applyPrepare: <TItem>(config: ExporterSliceConfig<TItem>, items: TItem[], cols: TableColumnDef<TItem>[]) => Promise<{
+        items: TItem[];
+        cols: TableColumnDef<TItem>[];
+    }>;
+    download: <TItem>(config: ExporterSliceConfig<TItem>, ctx: ExporterDependencies<TItem>, opts: {
+        type: "csv" | "excel";
+    }) => Promise<void>;
+};

package/dist/System/Slices/Exporter/ExporterSlice.d.ts

@@ -0,0 +1,4 @@
+import { ExporterAPI, ExporterSliceConfig } from "./Types";
+export declare function ExporterSlice<TItem = any>(config?: ExporterSliceConfig<TItem>): (ctx: any) => {
+    exporter: ExporterAPI;
+};

package/dist/System/Slices/Exporter/Types.d.ts

@@ -0,0 +1,35 @@
+import { PaginatorAPI } from "../Paginator/Types";
+import { StatusAPI } from "../Status/Types";
+import { TableAPI, TableColumnDef } from "../Table/Types";
+import { LoaderAPI } from "../Loader/Types";
+export type ExporterSliceConfig<TItem> = {
+    columns?: TableColumnDef<TItem>[];
+    /**
+     * prepare receives the resolved items and resolved columns.
+     * It may:
+     * - return a new items array,
+     * - return { items?, cols? } to modify either,
+     * - or return void/undefined to not change anything.
+     */
+    prepare?: (items: TItem[], cols: TableColumnDef<TItem>[]) => Promise<TItem[] | {
+        items?: TItem[];
+        cols?: TableColumnDef<TItem>[];
+    } | void> | TItem[] | {
+        items?: TItem[];
+        cols?: TableColumnDef<TItem>[];
+    } | void;
+    filename?: (type: "csv" | "excel") => string;
+    dataProvider?: (ctx: any) => TItem[] | Promise<TItem[]>;
+    useStatus?: boolean;
+};
+export interface ExporterAPI {
+    download: (opts: {
+        type: "csv" | "excel";
+    }) => Promise<void>;
+}
+export interface ExporterDependencies<TItem> {
+    paginator?: PaginatorAPI<TItem>;
+    loader?: LoaderAPI<TItem[]>;
+    table: TableAPI<TItem>;
+    status?: StatusAPI;
+}

package/dist/System/Slices/Loader/LoaderMechanics.d.ts

@@ -0,0 +1,5 @@
+import { LoaderFunction, LoaderProps } from "./Types";
+export declare const LoaderMechanics: {
+    load: <L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined>(config: LoaderProps<L, R, Fmt>, params?: any, clearCache?: boolean) => Promise<Fmt extends undefined ? R : Fmt>;
+    reload: <L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined>(config: LoaderProps<L, R, Fmt>, params?: any) => Promise<Fmt extends undefined ? R : Fmt>;
+};

package/dist/System/Slices/Loader/LoaderSlice.d.ts

@@ -0,0 +1,15 @@
+import { LoaderAPI, LoaderDependencies, LoaderFunction, LoaderProps } from "./Types";
+/**
+ * LoaderSlice - Handles data loading with loading states
+ *
+ * ⚠️ **Requires:** StatusSlice must be added before this slice
+ *
+ * @example
+ * // ✅ Correct
+ * createFactory()
+ *   .use(StatusSlice())
+ *   .use(LoaderSlice({ loader: myLoader }))
+ */
+export declare function LoaderSlice<L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined>(props: LoaderProps<L, R, Fmt>): (ctx: LoaderDependencies) => {
+    loader: LoaderAPI<Fmt extends undefined ? R : Fmt>;
+};

package/dist/System/Slices/Loader/Types.d.ts

@@ -0,0 +1,25 @@
+import { IHive } from "../../../Hives";
+import { StatusAPI } from "../Status/Types";
+import { QueryAPI } from "../Query/Types";
+export type LoaderFunction<Params = any, Response = any> = (params?: Params, clearCache?: boolean) => Promise<Response>;
+export interface LoaderProps<L extends LoaderFunction, R = Awaited<ReturnType<L>>, Fmt = undefined, Q = any> {
+    loader: L;
+    format?: (raw: R) => Fmt;
+    onError?: (e: unknown) => void;
+    shouldLoadOnQueryChange?: (query: Q, controls: {
+        clear: () => void;
+    }) => boolean;
+    statusProps?: {
+        useStatus?: boolean;
+    };
+}
+export interface LoaderAPI<Response> {
+    loaderHive: IHive<Response>;
+    load: (params?: any, clearCache?: boolean) => Promise<void>;
+    reload: (params?: any) => Promise<void>;
+    isLoading: () => boolean;
+}
+export interface LoaderDependencies {
+    status: StatusAPI;
+    query?: QueryAPI<any, any>;
+}

package/dist/System/Slices/Paginator/PaginatorMechanics.d.ts

@@ -0,0 +1,17 @@
+import { IHive, IHiveArray } from "../../../Hives";
+import { PaginatorDependencies, PaginatorProps } from "./Types";
+export type ArrayElement<R> = R extends Array<infer U> ? U : R extends {
+    batch: Array<infer V>;
+} ? V : R extends {
+    data: Array<infer W>;
+} ? W : never;
+export declare const PaginatorMechanics: {
+    getArrayFromResponse: <R>(response: R) => ArrayElement<R>[];
+    exec: <P extends {
+        load: (...args: any[]) => Promise<any>;
+        reload: (...args: any[]) => Promise<any>;
+        loadMore: () => Promise<any>;
+        hasMore: boolean;
+        limit: number;
+    }, R, F, Item>(ctx: PaginatorDependencies, props: PaginatorProps<P, R, F>, hive: IHiveArray<Item>, canLoadHive: IHive<boolean>, fn: () => Promise<R>, append: boolean) => Promise<void>;
+};

package/dist/System/Slices/Paginator/PaginatorSlice.d.ts

@@ -0,0 +1,22 @@
+import { ArrayElement } from "./PaginatorMechanics";
+import { PaginatorAPI, PaginatorDependencies, PaginatorProps } from "./Types";
+/**
+ * PaginatorSlice - Handles pagination with loading states
+ *
+ * ⚠️ **Requires:** StatusSlice must be added before this slice
+ *
+ * @example
+ * // ✅ Correct
+ * createFactory()
+ *   .use(StatusSlice())
+ *   .use(PaginatorSlice({ paginator: myPaginator }))
+ */
+export declare function PaginatorSlice<P extends {
+    load: (...args: any[]) => Promise<any>;
+    reload: (...args: any[]) => Promise<any>;
+    loadMore: () => Promise<any>;
+    hasMore: boolean;
+    limit: number;
+}, R = Awaited<ReturnType<P["load"]>>, F = undefined>(props: PaginatorProps<P, R, F>): (ctx: PaginatorDependencies) => {
+    paginator: PaginatorAPI<ArrayElement<F extends undefined ? R : F>>;
+};

package/dist/System/Slices/Paginator/Types.d.ts

@@ -0,0 +1,30 @@
+import { IHive, IHiveArray } from "../../../Hives";
+import { StatusAPI } from "../Status/Types";
+import { QueryAPI } from "../Query/Types";
+export interface PaginatorProps<P extends {
+    load: (...args: any[]) => Promise<any>;
+    reload: (...args: any[]) => Promise<any>;
+    loadMore: () => Promise<any>;
+    hasMore: boolean;
+    limit: number;
+}, R = Awaited<ReturnType<P["load"]>>, F = undefined, Q = any> {
+    paginator: P;
+    format?: (raw: R) => F;
+    onError?: (e: unknown) => void;
+    shouldLoadOnQueryChange?: (query: Q, controls: {
+        clear: () => void;
+    }) => boolean;
+}
+export interface PaginatorAPI<Item, Query = any> {
+    paginatorHive: IHiveArray<Item>;
+    load: (q?: Query) => Promise<void>;
+    reload: (q?: Query) => Promise<void>;
+    loadMore: () => Promise<void>;
+    hasMore: boolean;
+    limit: number;
+    canLoadHive: IHive<boolean>;
+}
+export interface PaginatorDependencies {
+    status: StatusAPI;
+    query?: QueryAPI<any>;
+}

package/dist/System/Slices/Query/Components/Filters.d.ts

@@ -0,0 +1,8 @@
+import { QueryAPI } from "../Types";
+import React from "react";
+type Props = {
+    querySlice: QueryAPI<any>;
+    filterClass?: string;
+};
+export declare const Filters: ({ querySlice, filterClass }: Props) => React.JSX.Element;
+export {};

package/dist/System/Slices/Query/Components/QueryContainer.d.ts

@@ -0,0 +1,9 @@
+import { IQueryFactory } from "../../../Factories/Types";
+import React from "react";
+type Props = {
+    factory: IQueryFactory<any>;
+    children?: any;
+    filterClass?: string;
+};
+declare const QueryContainer: ({ children, factory }: Props) => React.JSX.Element;
+export default QueryContainer;

package/dist/System/Slices/Query/Components/QueryElements.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { QueryAPI } from "../Types";
+export interface IQueryProps {
+    id: string;
+    query: QueryAPI<any>;
+    debounce?: number;
+    [key: string]: any;
+}
+interface IQueryElementProps extends IQueryProps {
+    Element: any;
+}
+interface IQueryElementLabeledProps extends IQueryElementProps {
+    label?: any;
+    customLabel?: string;
+}
+export declare const QueryElementLabeled: ({ id, no_label, query, label, customLabel, Element, debounce, ...props }: IQueryElementLabeledProps) => React.JSX.Element;
+export declare const QueryElement: ({ id, query, Element, debounce, ...props }: IQueryElementProps) => React.JSX.Element;
+export {};

package/dist/System/Slices/Query/QueryMechanics.d.ts

@@ -0,0 +1,13 @@
+import { IHive } from "../../../Hives";
+import { FilterDefinition, IdOf, QueryRecord, QuerySliceConfig } from "./Types";
+export declare const QueryMechanics: {
+    createHive: <F extends Record<string, FilterDefinition>>(config: QuerySliceConfig<any, F>) => IHive<QueryRecord<F>>;
+    syncInitialQuery: <F extends Record<string, FilterDefinition>>(hive: IHive<QueryRecord<F>>, config: QuerySliceConfig<any, F>) => Promise<void>;
+    validate: <F extends Record<string, FilterDefinition>>(config: QuerySliceConfig<any, F>, key: IdOf<F>, value: any) => boolean | string;
+    setQuery: <F extends Record<string, FilterDefinition>>(hive: IHive<QueryRecord<F>>, q: QueryRecord<F>, config: QuerySliceConfig<any, F>) => void;
+    updateQuery: <F extends Record<string, FilterDefinition>, K extends IdOf<F>>(hive: IHive<QueryRecord<F>>, patch: {
+        id: K;
+        value: any;
+    }, config: QuerySliceConfig<any, F>) => boolean;
+    removeParam: <F extends Record<string, FilterDefinition>>(hive: IHive<QueryRecord<F>>, key: IdOf<F>, config: QuerySliceConfig<any, F>) => Promise<void>;
+};

package/dist/System/Slices/Query/QuerySlice.d.ts

@@ -0,0 +1,4 @@
+import { FilterDefinition, QueryAPI, QueryComponentMap, QuerySliceConfig } from "./Types";
+export declare function QuerySlice<M extends QueryComponentMap, F extends Record<string, FilterDefinition<M>>>(config: QuerySliceConfig<M, F>): (_: any) => {
+    query: QueryAPI<M, F>;
+};

package/dist/System/Slices/Query/Types.d.ts

@@ -0,0 +1,46 @@
+import { ComponentProps } from "react";
+import { IHive } from "../../../Hives";
+export type ParrotKey = string;
+export type QueryComponentMap = Record<string, React.FC<any>>;
+type CommonFilterProps = {
+    label?: ParrotKey;
+    placement?: "InLine" | "InPopup" | "Auto";
+    isMain?: boolean;
+    value?: any;
+};
+export type FilterDefinition<M extends QueryComponentMap = any> = {
+    [K in keyof M]: {
+        type: K;
+    } & Omit<ComponentProps<M[K]>, keyof CommonFilterProps | "queryBuilder" | "id"> & CommonFilterProps;
+}[keyof M];
+export type IdOf<F extends Record<string, any>> = Extract<keyof F, string>;
+export type QueryRecord<F extends Record<string, any>> = {
+    [K in keyof F]?: any;
+};
+export interface QueryValidator<F extends Record<string, any>> {
+    <K extends keyof F>(key: K, value: any): boolean | string;
+}
+export interface QuerySliceConfig<M extends QueryComponentMap = any, F extends Record<string, FilterDefinition<M>> = any> {
+    componentMap: M;
+    filters: F;
+    validators?: Array<QueryValidator<F>>;
+    onQueryChange?: (query: QueryRecord<F>) => void;
+    syncWithRouter?: boolean;
+}
+export interface QueryAPI<M extends QueryComponentMap = any, F extends Record<string, FilterDefinition<M>> = any> {
+    filters: F;
+    queryHive: IHive<QueryRecord<F>>;
+    getParam: <K extends IdOf<F>>(key: K) => any;
+    getQuery: () => QueryRecord<F>;
+    setQuery: (q: QueryRecord<F>) => void;
+    updateQuery: <K extends IdOf<F>>(patch: {
+        id: K;
+        value: any;
+    }) => boolean;
+    removeParam: (key: IdOf<F>) => void;
+    clearQuery: () => void;
+    listenToQuery: (cb: (q: QueryRecord<F>) => void) => () => void;
+    componentMap: M;
+    getFilterComponent: (type: keyof M) => React.FC<any>;
+}
+export {};

package/dist/System/Slices/Status/Components/StatusIndicator.d.ts

@@ -0,0 +1,91 @@
+import { ReactNode } from "react";
+import { StatusAPI, StatusKit, StatusTypeNames, OperationState } from "../Types";
+interface StatusIndicatorProps<K extends StatusKit> {
+    /** The status API from the factory */
+    status: StatusAPI<K>;
+    /** Optional: Only listen to these operations */
+    operations?: string[];
+    /** Optional: Only show these status types */
+    statusTypes?: StatusTypeNames<K>[];
+    /** Optional: Custom render function */
+    children?: (state: OperationState<K> | null) => ReactNode;
+}
+/**
+ * StatusIndicator - Displays status based on active operations
+ *
+ * @example
+ * // Show status for all operations
+ * <StatusIndicator status={status} />
+ *
+ * // Scoped to specific operations
+ * <StatusIndicator
+ *   status={status}
+ *   operations={['table', 'table-sort']}
+ * />
+ *
+ * // Custom render
+ * <StatusIndicator status={status}>
+ *   {(state) => state ? <CustomLoader /> : null}
+ * </StatusIndicator>
+ */
+export declare function StatusIndicator<K extends StatusKit>({ status, operations, statusTypes, children }: StatusIndicatorProps<K>): ReactNode;
+interface TypedIndicatorProps<K extends StatusKit> {
+    status: StatusAPI<K>;
+    operations?: string[];
+}
+/**
+ * LoadingIndicator - Only shows loading status
+ */
+export declare function LoadingIndicator<K extends StatusKit>({ status, operations }: TypedIndicatorProps<K>): ReactNode;
+/**
+ * ErrorDisplay - Only shows error status
+ */
+export declare function ErrorDisplay<K extends StatusKit>({ status, operations }: TypedIndicatorProps<K>): ReactNode;
+/**
+ * SuccessToast - Only shows success status
+ */
+export declare function SuccessToast<K extends StatusKit>({ status, operations }: TypedIndicatorProps<K>): ReactNode;
+interface StatusGuardProps<K extends StatusKit> {
+    status: StatusAPI<K>;
+    operations?: string[];
+    statusTypes?: StatusTypeNames<K>[];
+    fallback: ReactNode;
+    children: ReactNode;
+}
+/**
+ * StatusGuard - Show fallback while status is active, otherwise show children
+ *
+ * @example
+ * <StatusGuard
+ *   status={status}
+ *   operations={['table']}
+ *   fallback={<Skeleton />}
+ * >
+ *   <TableContent />
+ * </StatusGuard>
+ */
+export declare function StatusGuard<K extends StatusKit>({ status, operations, statusTypes, fallback, children }: StatusGuardProps<K>): ReactNode;
+interface ProgressBarProps<K extends StatusKit> {
+    status: StatusAPI<K>;
+    operations: string[];
+    className?: string;
+}
+/**
+ * ProgressBar - Shows progress from status props
+ *
+ * @example
+ * <ProgressBar
+ *   status={status}
+ *   operations={['upload']}
+ * />
+ */
+export declare function ProgressBar<K extends StatusKit>({ status, operations, className }: ProgressBarProps<K>): ReactNode;
+export declare const StatusComponents: {
+    StatusIndicator: typeof StatusIndicator;
+    LoadingIndicator: typeof LoadingIndicator;
+    ErrorDisplay: typeof ErrorDisplay;
+    SuccessToast: typeof SuccessToast;
+    StatusGuard: typeof StatusGuard;
+    ProgressBar: typeof ProgressBar;
+};
+export {};

package/dist/System/Slices/Status/Components/StatutsComopnent.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { StatusAPI, StatusKit } from "../Types";
+interface StatusComponentProps<K extends StatusKit> {
+    status: StatusAPI<K>;
+}
+/**
+ * StatusComponent - Renders the primary status using getComponent
+ *
+ * @deprecated Use StatusIndicator instead for more control
+ */
+declare function StatusComponent<K extends StatusKit>({ status }: StatusComponentProps<K>): React.JSX.Element | null;
+export default StatusComponent;

package/dist/System/Slices/Status/StatusSlice.d.ts

@@ -0,0 +1,22 @@
+import { StatusAPI, StatusKit, StatusSliceConfig } from "./Types";
+/**
+ * StatusSlice V3 - Operations-based status management
+ *
+ * Features:
+ * - Multiple concurrent operations
+ * - String-based operation names
+ * - Dynamic status type methods from StatusKit
+ * - Priority-based status resolution
+ * - Scoped component listeners
+ *
+ * @example
+ * // Basic usage
+ * ctx.status.operation('table').loading({ variant: 'skeleton' });
+ * ctx.status.operation('table').success({ message: 'Done!' });
+ *
+ * // Default operation
+ * ctx.status.ready().loading({ message: 'Loading...' });
+ */
+export declare function StatusSlice<K extends StatusKit>(config: StatusSliceConfig<K>): (_ctx: any) => {
+    status: StatusAPI<K>;
+};

package/dist/System/Slices/Status/Types.d.ts

@@ -0,0 +1,76 @@
+import { IHive } from "../../../Hives";
+import { ReactNode } from "react";
+/**
+ * Defines a single status type configuration
+ */
+export interface StatusTypeConfig<P = any> {
+    priority: number;
+    props: P;
+    component: (props: P) => ReactNode;
+}
+/**
+ * A StatusKit is a record of status type names to their configurations
+ */
+export type StatusKit = Record<string, StatusTypeConfig<any>>;
+/**
+ * Extract status type names from a StatusKit
+ */
+export type StatusTypeNames<K extends StatusKit> = keyof K & string;
+/**
+ * Extract props type for a specific status type from a StatusKit
+ */
+export type StatusPropsFor<K extends StatusKit, T extends StatusTypeNames<K>> = K[T]["props"];
+/**
+ * State for a single operation stored in the hive
+ */
+export interface OperationState<K extends StatusKit = StatusKit> {
+    operation: string;
+    statusType: StatusTypeNames<K>;
+    props: any;
+    priority: number;
+    startedAt: number;
+    timeout?: number;
+}
+/**
+ * Options for setting a status
+ */
+export interface StatusOptions {
+    timeout?: number;
+}
+/**
+ * The chain returned by operation(name) or ready()
+ * Dynamically typed based on the StatusKit
+ */
+export type OperationChain<K extends StatusKit = StatusKit> = {
+    [T in StatusTypeNames<K>]: (props: StatusPropsFor<K, T>, options?: StatusOptions) => void;
+} & {
+    idle: () => void;
+};
+/**
+ * The main StatusSlice API exposed to slices and components
+ */
+export interface StatusAPI<K extends StatusKit = StatusKit> {
+    operation: (name: string) => OperationChain<K>;
+    ready: () => OperationChain<K>;
+    isActive: (operation: string) => boolean;
+    isAnyActive: (operations: string[]) => boolean;
+    getState: (operation: string) => OperationState<K> | null;
+    getPrimary: (operations?: string[], statusTypes?: StatusTypeNames<K>[]) => OperationState<K> | null;
+    getActiveOperations: () => string[];
+    getComponent: (statusType: StatusTypeNames<K>) => (props: any) => ReactNode;
+    hive: IHive<Map<string, OperationState<K>>>;
+}
+/**
+ * Configuration for the StatusSlice
+ */
+export interface StatusSliceConfig<K extends StatusKit = StatusKit> {
+    statusKit: K;
+    staleTimeout?: number;
+    onStaleOperation?: (operation: OperationState<K>) => void;
+}
+export declare const DefaultStatusTypes: {
+    readonly idle: "idle";
+    readonly loading: "loading";
+    readonly success: "success";
+    readonly error: "error";
+};

package/dist/System/Slices/Table/Components.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const CellBuilder: (val: any, props?: any) => React.JSX.Element;

package/dist/System/Slices/Table/TableMechanics.d.ts

@@ -0,0 +1,20 @@
+import { TableColumnDef, TableSliceConfig, TableSort } from "./Types";
+export declare const TableMechanics: {
+    Storage: {
+        saveColumns: (key: string, columns: TableColumnDef<any>[]) => void;
+        getColumns: <T>(key: string) => Partial<TableColumnDef<T>>[];
+        clearColumns: (key: string) => void;
+    };
+    Sorting: {
+        sortRows: <T>(rows: T[], sorts: TableSort<T>[]) => T[];
+    };
+    Columns: {
+        initialize: <TItem>(config: TableSliceConfig<TItem>, ctx: any, storeKey: string) => TableColumnDef<TItem>[];
+        setVisible: <TItem>(config: TableSliceConfig<TItem>, ctx: any, cols: TableColumnDef<TItem>[], storeKey: string) => TableColumnDef<TItem>[];
+    };
+    Selection: {
+        toggle: <TItem>(prev: Record<string, TItem>, item: any, idKey: string) => Record<string, TItem>;
+        isAllSelected: <TItem>(rows: TItem[], selected: Record<string, TItem>, idKey: string) => boolean;
+        selectAll: <TItem>(rows: TItem[], idKey: string) => Record<string, TItem>;
+    };
+};

package/dist/System/Slices/Table/TableSlice.d.ts

@@ -0,0 +1,4 @@
+import { TableAPI, TableDependencies, TableSliceConfig } from "./Types";
+export declare function TableSlice<TItem = any, Ctx = any>(config: TableSliceConfig<TItem, Ctx>): (ctx: Ctx & TableDependencies<TItem>) => {
+    table: TableAPI<TItem>;
+};