onekijs-ui 0.9.2 → 0.15.2

package/dist/components/properties/components/Property.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { PropertyProps } from '../typings';
+declare const Property: FC<PropertyProps>;
+export default Property;

package/dist/components/properties/hooks/usePropertiesContext.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { PropertiesContext } from '../typings';
+export declare const DefaultPropertiesContext: React.Context<PropertiesContext>;
+declare const usePropertiesContext: () => PropertiesContext;
+export default usePropertiesContext;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Properties: import("styled-components").StyledComponent<import("react").FC<import("./typings").PropertiesProps>, any, {}, never>;
+export default Properties;

package/dist/components/properties/style.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStyle } from '../../styles/typings';
+import { PropertiesProps } from './typings';
+export declare const propertiesStyle: ComponentStyle<PropertiesProps>;

package/dist/components/properties/typings.d.ts

@@ -0,0 +1,26 @@
+import { AnonymousObject } from 'onekijs-framework';
+import React, { ReactNode } from 'react';
+import { GridSize } from '../grid/typings';
+export declare type PropertiesProps = {
+    properties: PropertiesList;
+    PropertyComponent?: React.FC<PropertyProps>;
+    order?: boolean;
+    className?: string;
+    size?: GridSize;
+    sm?: GridSize;
+    md?: GridSize;
+    lg?: GridSize;
+    xl?: GridSize;
+};
+export declare type PropertyProps = {
+    value: ReactNode;
+    name: string;
+};
+export declare type PropertiesContext = {
+    size?: GridSize;
+    sm?: GridSize;
+    md?: GridSize;
+    lg?: GridSize;
+    xl?: GridSize;
+};
+export declare type PropertiesList = AnonymousObject<ReactNode>;

package/dist/components/resizer/ResizerService.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { Task } from '@redux-saga/types';
+import { DefaultService } from 'onekijs-framework';
+import { ResizerHandle, ResizerHandler, ResizerState } from './typings';
+export declare class ResizerService extends DefaultService<ResizerState> {
+    protected hoverTask: Task | null;
+    protected currentHandle?: ResizerHandle;
+    setSize(width: number, height: number, lastX: number, lastY: number): void;
+    setHover(hover: boolean): void;
+    delayEnter(delay_ms: number): Generator<void | import("@redux-saga/core/effects").CallEffect<true>, void, unknown>;
+    onEnter(): Generator<import("@redux-saga/core/effects").ForkEffect<Generator<void | import("@redux-saga/core/effects").CallEffect<true>, void, unknown>>, void, Task<any> | null>;
+    onLeave(): Generator<import("@redux-saga/core/effects").CancelEffect, void, unknown>;
+    onResize(e: any): Generator<void, void, unknown>;
+    startResize(handle: ResizerHandle, target: React.RefObject<HTMLDivElement>, x: number, y: number): void;
+    stopResize(): void;
+}
+export declare const useResizerService: (handler: ResizerHandler) => [ResizerState, ResizerService];

package/dist/components/resizer/components/ResizerComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { ResizerProps } from '../typings';
+declare const ResizerComponent: FCC<ResizerProps>;
+export default ResizerComponent;

package/dist/components/resizer/components/ResizerHorizontalSplitter.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { ResizeHorizontalSplitterProps } from '../typings';
+declare const ResizerHorizontalSplitter: FCC<ResizeHorizontalSplitterProps>;
+export default ResizerHorizontalSplitter;

package/dist/components/resizer/components/ResizerVerticalSplitter.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { ResizeVerticalSplitterProps } from '../typings';
+declare const ResizerVerticalSplitter: FCC<ResizeVerticalSplitterProps>;
+export default ResizerVerticalSplitter;

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

@@ -0,0 +1,2 @@
+declare const Resizer: import("styled-components").StyledComponent<import("onekijs-framework").FCC<import("./typings").ResizerProps>, any, {}, never>;
+export default Resizer;

package/dist/components/resizer/style.d.ts

@@ -0,0 +1,4 @@
+import { ComponentStyle } from '../../styles/typings';
+import { ResizerProps } from './typings';
+declare const resizerStyle: ComponentStyle<ResizerProps>;
+export default resizerStyle;

package/dist/components/resizer/typings.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+export declare type ResizerVerticalHandle = 'e' | 'w';
+export declare type ResizerHorizontallHandle = 'n' | 's';
+export declare type ResizerHandle = ResizerVerticalHandle | ResizerHorizontallHandle | 'se' | 'sw' | 'nw' | 'all';
+export declare type ResizeStep = 'start' | 'stop' | 'run';
+export declare type ResizerHandler = (step: ResizeStep, nextWidth: number, nextHeight: number) => void;
+export interface ResizerProps {
+    className?: string;
+    onResize: ResizerHandler;
+    handles?: ResizerHandle[];
+    minWidth?: string | 0;
+    maxWidth?: string | 0;
+    minHeight?: string | 0;
+    maxHeight?: string | 0;
+}
+export interface ResizeSplitterProps {
+    onResize: ResizerHandler;
+    target: React.RefObject<HTMLDivElement>;
+}
+export interface ResizeVerticalSplitterProps extends ResizeSplitterProps {
+    handle: ResizerVerticalHandle;
+}
+export interface ResizeHorizontalSplitterProps extends ResizeSplitterProps {
+    handle: ResizerHorizontallHandle;
+}
+export interface ResizerState {
+    active?: boolean;
+    height?: number;
+    hover?: boolean;
+    lastX?: number;
+    lastY?: number;
+    width?: number;
+    handler: ResizerHandler;
+}

package/dist/components/select/FormSelect.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { FormSelectProps } from './typings';
+declare const FormSelect: FC<FormSelectProps>;
+export default FormSelect;

package/dist/components/select/SelectService.d.ts

@@ -0,0 +1,5 @@
+import { CollectionService } from 'onekijs-framework';
+import { SelectController, SelectItem, SelectState } from './typings';
+declare class SelectService<T = any, I extends SelectItem<T> = SelectItem<T>, S extends SelectState<T, I> = SelectState<T, I>> extends CollectionService<T, I, S> implements SelectController<T, I> {
+}
+export default SelectService;

package/dist/components/select/components/ArraySelectComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ArraySelectProps } from '../typings';
+declare const ArraySelectComponent: FC<ArraySelectProps>;
+export default ArraySelectComponent;

package/dist/components/select/components/ControllerSelectComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ControllerSelectProps } from '../typings';
+declare const ControllerSelectComponent: FC<ControllerSelectProps>;
+export default ControllerSelectComponent;

package/dist/components/select/components/SelectComponent.d.ts

@@ -1,4 +1,4 @@
-import { FC } from 'react';
-import { SelectProps } from '../typings';
-declare const SelectComponent: FC<SelectProps<any>>;
-export default SelectComponent;
+import React from 'react';
+import { SelectProps } from '../typings';
+declare const SelectComponent: React.FC<SelectProps>;
+export default SelectComponent;

package/dist/components/select/components/SelectIconComponent.d.ts

@@ -1,4 +1,4 @@
-import { FC } from 'react';
-import { SelectIconProps } from '../typings';
-declare const SelectIconComponent: FC<SelectIconProps>;
-export default SelectIconComponent;
+import { FC } from 'react';
+import { SelectIconProps } from '../typings';
+declare const SelectIconComponent: FC<SelectIconProps>;
+export default SelectIconComponent;

package/dist/components/select/components/SelectInputComponent.d.ts

@@ -1,4 +1,4 @@
-import { FC } from 'react';
-import { SelectInputProps } from '../typings';
-declare const SelectInputComponent: FC<SelectInputProps>;
-export default SelectInputComponent;
+import React from 'react';
+import { SelectInputProps } from '../typings';
+declare const SelectInputComponent: React.ForwardRefExoticComponent<SelectInputProps<any, import("../typings").SelectItem<any>> & React.RefAttributes<HTMLDivElement>>;
+export default SelectInputComponent;

package/dist/components/select/components/SelectNotFoundComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { SelectNotFoundProps } from '../typings';
+declare const SelectNotFoundComponent: React.FC<SelectNotFoundProps>;
+export default SelectNotFoundComponent;

package/dist/components/select/components/SelectOptionComponent.d.ts

@@ -1,4 +1,6 @@
-import { FC } from 'react';
-import { SelectOptionProps } from '../typings';
-declare const SelectOptionComponent: FC<SelectOptionProps>;
-export default SelectOptionComponent;
+import { FC } from 'react';
+import { SelectOptionProps } from '../typings';
+export declare const MultiSelectOptionComponent: FC<SelectOptionProps>;
+export declare const SelectOptionContent: FC<SelectOptionProps>;
+declare const SelectOptionComponent: FC<SelectOptionProps>;
+export default SelectOptionComponent;

package/dist/components/select/components/SelectTokenComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { SelectTokenProps } from '../typings';
+declare const SelectTokenComponent: FC<SelectTokenProps>;
+export default SelectTokenComponent;

package/dist/components/select/components/SelectTokensComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { SelectTokensProps } from '../typings';
+declare const SelectTokensComponent: FC<SelectTokensProps>;
+export default SelectTokensComponent;

package/dist/components/select/hooks/useSelectConfig.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { SelectConfig, SelectItem } from '../typings';
+export declare const SelectConfigContext: React.Context<SelectConfig<any, any>>;
+export declare const useSelectConfig: <T = any, I extends SelectItem<T> = SelectItem<T>>() => SelectConfig<T, I>;

package/dist/components/select/hooks/useSelectController.d.ts

@@ -0,0 +1,6 @@
+import { CollectionProxy } from 'onekijs-framework';
+import { UseListOptions } from '../../list/typings';
+import SelectService from '../SelectService';
+import { SelectItem, SelectState } from '../typings';
+declare const useSelectController: <T = any>(dataSource: string | T[], options?: UseListOptions<T, SelectItem<T>>) => CollectionProxy<T, SelectItem<T>, SelectState<T, SelectItem<T>>, SelectService<T, SelectItem<T>, SelectState<T, SelectItem<T>>>>;
+export default useSelectController;

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

@@ -1,3 +1,3 @@
-/// <reference types="react" />
-declare const Select: import("styled-components").StyledComponent<import("react").FC<import("./typings").SelectProps<any, import("./typings").SelectOptionMeta>>, any, {}, never>;
-export default Select;
+/// <reference types="react" />
+declare const Select: import("styled-components").StyledComponent<import("react").FC<import("./typings").SelectProps<any, import("./typings").SelectItem<any>, import("./typings").SelectState<any, import("./typings").SelectItem<any>>, import("./typings").SelectController<any, import("./typings").SelectItem<any>, import("./typings").SelectState<any, import("./typings").SelectItem<any>>>>>, any, {}, never>;
+export default Select;

package/dist/components/select/style.d.ts

@@ -1,4 +1,4 @@
-import { ComponentStyle } from '../../styles/typings';
-import { SelectProps } from './typings';
-declare const selectStyle: ComponentStyle<SelectProps>;
-export default selectStyle;
+import { ComponentStyle } from '../../styles/typings';
+import { SelectProps } from './typings';
+declare const selectStyle: ComponentStyle<SelectProps>;
+export default selectStyle;

package/dist/components/select/typings.d.ts

@@ -1,37 +1,95 @@
-import { AnyFunction, ChangeHandler, Collection, ItemAdapter, ItemMeta } from 'onekijs-core';
-import { FC } from 'react';
-import { ListItemHandler, ListItemProps, ListProps } from '../list/typings';
-export declare type SelectAdapter<T, M extends SelectOptionMeta = SelectOptionMeta> = ItemAdapter<T, M>;
-export interface SelectIconProps {
-    open: boolean;
-    loading: boolean;
-    onIconClick: AnyFunction<void>;
-}
-export interface SelectInputProps extends React.InputHTMLAttributes<HTMLInputElement>, SelectIconProps {
-    IconComponent?: FC<SelectIconProps>;
-    focus?: boolean;
-}
-export declare type SelectInternalProps<T = any, M extends ItemMeta = SelectOptionMeta> = Omit<SelectProps, 'items'> & {
-    collection: Collection<T, M>;
-};
-export declare type SelectOptionHandler<T = any, M extends ItemMeta = SelectOptionMeta> = ListItemHandler<T, M>;
-export interface SelectOptionMeta extends ItemMeta {
-    selected?: boolean;
-    highlighted?: boolean;
-}
-export declare type SelectOptionProps<T = any, M extends SelectOptionMeta = SelectOptionMeta> = ListItemProps<T, M>;
-export interface SelectOptionsProps<T = any, M extends SelectOptionMeta = SelectOptionMeta> extends ListProps<T, M> {
-    search?: string;
-}
-export interface SelectProps<T = any, M extends SelectOptionMeta = SelectOptionMeta> extends ListProps<T, M> {
-    InputComponent?: FC<SelectInputProps>;
-    IconComponent?: FC<SelectIconProps>;
-    placeholder?: string;
-    value?: T | null;
-    onChange?: ChangeHandler<T>;
-    autoFocus?: boolean;
-    className?: string;
-}
-export interface ClickOutsideHandler {
-    handleClickOutside?: AnyFunction<void>;
-}
+import { AnyFunction, ChangeHandler, Collection, CollectionProxy, FormFieldProps, ValidationStatus } from 'onekijs-framework';
+import React, { FC } from 'react';
+import { TshirtSize } from '../../styles/typings';
+import { DropdownWidthModifier } from '../dropdown/typings';
+import { FieldLayoutProps } from '../field/typings';
+import { ListConfig, ListItem, ListItemAdaptee, ListItemAdapter, ListItemHandler, ListItemProps, ListNotFoundProps, ListState } from '../list/typings';
+export declare type ArraySelectProps<T = any, I extends SelectItem<T> = SelectItem<T>> = SelectConfig<T, I> & {
+    adapter?: SelectItemAdapter<T>;
+    dataSource: T[] | string;
+    fetchOnce?: boolean;
+};
+export declare type ControllerSelectProps<T = any, I extends SelectItem<T> = SelectItem<T>, S extends SelectState<T, I> = SelectState<T, I>, C extends SelectController<T, I, S> = SelectController<T, I, S>> = SelectConfig<T, I> & {
+    controller: CollectionProxy<T, I, S, C>;
+};
+export declare type FormSelectProps<T = any, I extends SelectItem<T> = SelectItem<T>> = SelectProps<T, I> & FormFieldProps & FieldLayoutProps & {
+    defaultValue?: T | T[] | null;
+    FieldComponent?: React.FC<SelectProps>;
+};
+export declare type SelectController<T, I extends SelectItem<T> = SelectItem<T>, S extends SelectState<T, I> = SelectState<T, I>> = Collection<T, I, S>;
+export interface SelectIconProps {
+    open: boolean;
+    loading: boolean;
+    fetching: boolean;
+    onClick: AnyFunction<void>;
+}
+export interface SelectInputProps<T = any, I extends SelectItem<T> = SelectItem<T>> extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'> {
+    IconComponent?: FC<SelectIconProps>;
+    focus: boolean;
+    value?: string;
+    tokens?: SelectItem<T>[];
+    open: boolean;
+    loading: boolean;
+    fetching: boolean;
+    setOpen: (open: boolean) => void;
+    onChange: (nextValue: string | null) => void;
+    multiple: boolean;
+    onRemove: SelectOptionHandler<T, I>;
+    style?: React.CSSProperties;
+    nullable?: boolean;
+    clickable: boolean;
+    minChars: number;
+}
+export declare type SelectItem<T = any> = ListItem<T>;
+export declare type SelectItemAdaptee = ListItemAdaptee;
+export declare type SelectItemAdapter<T = any> = ListItemAdapter<T>;
+export declare type SelectNotFoundProps = ListNotFoundProps;
+export declare type SelectOptionHandler<T = any, I extends SelectItem<T> = SelectItem<T>> = ListItemHandler<T, I>;
+export declare type SelectOptionSelectionHandler<T = any, I extends SelectItem<T> = SelectItem<T>> = (item: I, index: number, close?: boolean) => void;
+export declare type SelectOptionProps<T = any, I extends SelectItem<T> = SelectItem<T>> = ListItemProps<T, I> & {
+    multiple?: boolean;
+};
+export declare type SelectProps<T = any, I extends SelectItem<T> = SelectItem<T>, S extends SelectState<T, I> = SelectState<T, I>, C extends SelectController<T, I, S> = SelectController<T, I, S>> = SelectConfig<T, I> & {
+    adapter?: SelectItemAdapter<T>;
+    controller?: CollectionProxy<T, I, S, C>;
+    dataSource?: T[] | string;
+    fetchOnce?: boolean;
+};
+export declare type SelectConfig<T = any, I extends SelectItem<T> = SelectItem<T>> = Omit<ListConfig<T, I>, 'ItemComponent'> & {
+    attachDropdownToBody?: boolean;
+    InputComponent?: FC<SelectInputProps<T, I>>;
+    IconComponent?: FC<SelectIconProps>;
+    NotFoundComponent?: FC<SelectNotFoundProps>;
+    placeholder?: string;
+    value?: T | T[] | null;
+    onChange?: ChangeHandler<T>;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    autoFocus?: boolean;
+    className?: string;
+    multiple?: boolean;
+    status?: ValidationStatus;
+    name?: string;
+    size?: TshirtSize;
+    nullable?: boolean;
+    minChars?: number;
+    openOnFocus?: boolean;
+    clickable?: boolean;
+    dropdownWidthModifier?: DropdownWidthModifier;
+    OptionComponent?: FC<SelectOptionProps>;
+    OptionContentComponent?: FC<SelectOptionProps>;
+    OptionLoadingComponent?: FC;
+    MultiOptionsComponent?: FC<SelectOptionProps>;
+    animationMs?: number;
+    disabled?: boolean;
+};
+export declare type SelectState<T = any, I extends SelectItem<T> = SelectItem<T>> = ListState<T, I>;
+export interface SelectTokensProps<T = any, I extends SelectItem<T> = SelectItem<T>> {
+    tokens?: I[];
+    onRemove: SelectOptionHandler<T, I>;
+}
+export interface SelectTokenProps<T = any, I extends SelectItem<T> = SelectItem<T>> {
+    token: I;
+    onRemove: SelectOptionHandler<T, I>;
+    index: number;
+}

package/dist/components/tab/TabsService.d.ts

@@ -0,0 +1,24 @@
+import { ContainerValidation, DefaultService } from 'onekijs-framework';
+import { ReactNode } from 'react';
+import { TabsState, TabState } from './typings';
+export declare class TabsService<M extends TabState = TabState, S extends TabsState<M> = TabsState<M>> extends DefaultService<S> {
+    activate(uid: string): void;
+    disable(uid: string): void;
+    enable(uid: string): void;
+    getCurrentActiveIndex(): number;
+    getMember(uid: string): M | undefined;
+    hide(uid: string): void;
+    initMember(state: M): void;
+    onValidationChange(uid: string, touchedValidation: ContainerValidation, allValidation: ContainerValidation): void;
+    remove(uid: string): void;
+    setClosable(uid: string, closable: boolean): void;
+    setError(uid: string, message: string | null): void;
+    setIcon(uid: string, icon?: ReactNode): void;
+    setLoading(uid: string, loading: boolean): void;
+    setTitle(uid: string, title: string): void;
+    setWarning(uid: string, message: string | null): void;
+    show(uid: string): void;
+    touched(uid: string): void;
+    touching(uid: string): void;
+    _onValidationChange(uid: string, validation: ContainerValidation, touching: boolean): void;
+}

package/dist/components/tab/components/ControlledTabsComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { ControlledTabsProps } from '../typings';
+declare const ControlledTabsComponent: FCC<ControlledTabsProps>;
+export default ControlledTabsComponent;

package/dist/components/tab/components/Tab.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TabProps } from '../typings';
+declare const Tab: FCC<TabProps>;
+export default Tab;

package/dist/components/tab/components/TabTitle.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TabTitleProps } from '../typings';
+declare const TabTitle: FC<TabTitleProps>;
+export default TabTitle;

package/dist/components/tab/components/TabsComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TabsProps } from '../typings';
+declare const TabsComponent: FCC<TabsProps>;
+export default TabsComponent;

package/dist/components/tab/components/TabsContainer.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TabsProps } from '../typings';
+declare const TabsContainer: FCC<Omit<TabsProps, 'Component'>>;
+export default TabsContainer;

package/dist/components/tab/components/UncontrolledTabsComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TabsProps } from '../typings';
+declare const UncontrolledTabsComponent: FCC<TabsProps>;
+export default UncontrolledTabsComponent;

package/dist/components/tab/hooks/useTab.d.ts

@@ -0,0 +1,5 @@
+import { TabState } from '../typings';
+declare const useTab: (props: TabState & {
+    uid: string;
+}) => TabState | undefined;
+export default useTab;

package/dist/components/tab/hooks/useTabsController.d.ts

@@ -0,0 +1,3 @@
+import { UseTabsController } from '../typings';
+declare const useTabsController: UseTabsController;
+export default useTabsController;

package/dist/components/tab/hooks/useTabsService.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TabsService } from '../TabsService';
+export declare const TabsServiceContext: React.Context<TabsService<import("../typings").TabState, import("../typings").TabsState<import("../typings").TabState>>>;
+declare const useTabsService: () => TabsService;
+export default useTabsService;

package/dist/components/tab/hooks/useTabsState.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TabsState } from '../typings';
+export declare const TabsStateContext: React.Context<TabsState<import("../typings").TabState>>;
+export declare const useTabsState: () => TabsState;

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

@@ -0,0 +1,2 @@
+declare const Tabs: import("styled-components").StyledComponent<import("onekijs-framework").FCC<import("./typings").TabsProps>, any, {}, never>;
+export default Tabs;

package/dist/components/tab/style.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStyle } from '../../styles/typings';
+import { TabsProps } from './typings';
+export declare const tabsStyle: ComponentStyle<TabsProps>;

package/dist/components/tab/typings.d.ts

@@ -0,0 +1,54 @@
+import { AnonymousObject, AnyFunction, FCC } from 'onekijs-framework';
+import { ReactNode } from 'react';
+import { TabsService } from './TabsService';
+export declare type TabProps = {
+    active?: boolean;
+    title: string;
+    visible?: boolean;
+    closable?: boolean;
+    disabled?: boolean;
+    icon?: ReactNode;
+    uid?: string;
+};
+export declare type TabTitleProps<M extends TabState = TabState> = {
+    member: M;
+    onActivate: (member: M) => void;
+};
+export declare type TabState = {
+    active: boolean;
+    closable: boolean;
+    disabled: boolean;
+    error?: string;
+    icon?: ReactNode;
+    loading: boolean;
+    success?: boolean;
+    title: string;
+    touching: boolean;
+    touched: boolean;
+    touchingError?: string;
+    touchingWarning?: string;
+    uid: string;
+    visible: boolean;
+    warning?: string;
+};
+export declare type TabsProps = {
+    Component?: FCC<Omit<TabsProps, 'Component'>>;
+    TitleComponent?: React.FC<TabTitleProps>;
+    className?: string;
+    animate?: number;
+    controller?: TabsService;
+    onAdd?: AnyFunction;
+    layout?: 'horizontal' | 'vertical';
+};
+export declare type ControlledTabsProps = TabsProps & {
+    controller: TabsService;
+};
+export declare type TabsState<M extends TabState = TabState> = {
+    members: M[];
+    membersIndex: AnonymousObject<number>;
+    animate: number;
+    active?: string;
+};
+export declare type UseTabsController = (props: {
+    animate?: number;
+}) => TabsService;

package/dist/components/table/FormTable.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { FormTableProps, TableItem } from './typings';
+declare const FormTable: FC<FormTableProps<any, TableItem<any>>>;
+export default FormTable;

package/dist/components/table/TableService.d.ts

@@ -0,0 +1,18 @@
+import { AnonymousObject, CollectionService } from 'onekijs-framework';
+import React from 'react';
+import { TableColumn, TableColumnWidth, TableController, TableItem, TableState } from './typings';
+export declare const parseColumnWidth: (width?: string | number) => TableColumnWidth;
+declare class TableService<T = any, I extends TableItem<T> = TableItem<T>, S extends TableState<T, I> = TableState<T, I>> extends CollectionService<T, I, S> implements TableController<T, I> {
+    protected cells: AnonymousObject<AnonymousObject<React.RefObject<HTMLDivElement>>>;
+    protected tableRef: React.RefObject<HTMLDivElement> | null;
+    protected contentRef: React.RefObject<HTMLDivElement> | null;
+    adapt(data: T | undefined): I;
+    addColumn(column: TableColumn<T, I>, position?: number): void;
+    get columns(): TableColumn<T, I>[];
+    initCell(rowNumber: number | 'header-title' | 'header-filter' | 'footer', colId: string, ref: React.RefObject<HTMLDivElement>): void;
+    removeColumn(id: string): void;
+    resetWidth(): void;
+    toggle(item: I): void;
+    protected _setCellWidth(fit: boolean): void;
+}
+export default TableService;

package/dist/components/table/columns/useCheckboxColumn.d.ts

@@ -0,0 +1,3 @@
+import { CheckboxColumn, TableItem, UseCheckboxColumnOptions } from '../typings';
+declare const useCheckboxColumn: <T = any, I extends TableItem<T> = TableItem<T>>(options: UseCheckboxColumnOptions<T, I>) => CheckboxColumn<T, I>;
+export default useCheckboxColumn;

package/dist/components/table/columns/useColumn.d.ts

@@ -0,0 +1,3 @@
+import { TableItem, TableColumnSpec, TableColumn } from '../typings';
+declare const useColumn: <T = any, I extends TableItem<T> = TableItem<T>>(options: TableColumnSpec<T, I>) => TableColumn<T, I>;
+export default useColumn;

package/dist/components/table/columns/useInputColumn.d.ts

@@ -0,0 +1,3 @@
+import { InputColumn, UseInputColumnOptions, TableItem } from '../typings';
+declare const useInputColumn: <T = any, I extends TableItem<T> = TableItem<T>>(options: UseInputColumnOptions<T, I>) => InputColumn<T, I>;
+export default useInputColumn;

package/dist/components/table/columns/useLinkColumn.d.ts

@@ -0,0 +1,3 @@
+import { TableColumn, TableItem, UseLinkColumnOptions } from '../typings';
+declare const useLinkColumn: <T = any, I extends TableItem<T> = TableItem<T>>(options: UseLinkColumnOptions<T, I>) => TableColumn<T, I>;
+export default useLinkColumn;

package/dist/components/table/columns/useSelectColumn.d.ts

@@ -0,0 +1,3 @@
+import { SelectColumn, TableItem, UseSelectColumnOptions } from '../typings';
+declare const useSelectColumn: <T = any>(options: UseSelectColumnOptions<T, TableItem<T>, any, import("../../..").SelectItem<any>>) => SelectColumn<T, TableItem<T>>;
+export default useSelectColumn;

package/dist/components/table/components/ArrayTableComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ArrayTableProps } from '../typings';
+declare const ArrayTableComponent: FC<ArrayTableProps>;
+export default ArrayTableComponent;

package/dist/components/table/components/ControllerTableComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ControllerTableProps } from '../typings';
+declare const ControllerTableComponent: React.FC<ControllerTableProps>;
+export default ControllerTableComponent;

package/dist/components/table/components/FormTableComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FormTableProps, TableItem } from '../typings';
+declare const FormTableComponent: React.FC<FormTableProps<any, TableItem<any>>>;
+export default FormTableComponent;

package/dist/components/table/components/TableBodyCellComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableBodyCellProps } from '../typings';
+declare const TableBodyCellComponent: FC<Omit<TableBodyCellProps, 'data'>>;
+export default TableBodyCellComponent;

package/dist/components/table/components/TableBodyComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableBodyProps } from '../typings';
+declare const TableBodyComponent: React.FC<TableBodyProps>;
+export default TableBodyComponent;