@archbase/components 3.0.0

package/dist/jsonschema/ArchbaseJsonSchemaEditor.types.d.ts

@@ -0,0 +1,131 @@
+export type Schema2 = {
+    jsonSchema: JSONSchema7;
+    isValidSchema?: boolean;
+    errorMessage?: string;
+    isReadOnly: boolean;
+    fieldId: number;
+};
+export interface AdvancedItemStateProps {
+    path: string;
+    item: JSONSchema7;
+}
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7TypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7Type = string | number | boolean | JSONSchema7Object | JSONSchema7Array | null;
+export interface JSONSchema7Object {
+    [key: string]: JSONSchema7Type;
+}
+export type JSONSchema7Array = Array<JSONSchema7Type>;
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema7Version = string;
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+export type JSONSchema7Definition = JSONSchema7 | boolean;
+export interface JSONSchema7 {
+    $id?: string;
+    $ref?: string;
+    $schema?: JSONSchema7Version;
+    $comment?: string;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+     */
+    type?: JSONSchema7TypeName | JSONSchema7TypeName[];
+    enum?: JSONSchema7Type[];
+    const?: JSONSchema7Type;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+     */
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+     */
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+     */
+    items?: JSONSchema7Definition | JSONSchema7Definition[];
+    additionalItems?: JSONSchema7Definition;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    contains?: JSONSchema7;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+     */
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    properties?: {
+        [key: string]: JSONSchema7Definition;
+    };
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    };
+    additionalProperties?: JSONSchema7Definition;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    };
+    propertyNames?: JSONSchema7Definition;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+     */
+    if?: JSONSchema7Definition;
+    then?: JSONSchema7Definition;
+    else?: JSONSchema7Definition;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+     */
+    allOf?: JSONSchema7Definition[];
+    anyOf?: JSONSchema7Definition[];
+    oneOf?: JSONSchema7Definition[];
+    not?: JSONSchema7Definition;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+     */
+    format?: string;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+     */
+    contentMediaType?: string;
+    contentEncoding?: string;
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+     */
+    definitions?: {
+        [key: string]: JSONSchema7Definition;
+    };
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+     */
+    title?: string;
+    description?: string;
+    default?: JSONSchema7Type;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    examples?: JSONSchema7Type;
+}

package/dist/jsonschema/JsonSchemaEditor/ArchbaseJsonSchemaEditor.context.d.ts

@@ -0,0 +1,7 @@
+import { SetNestedObjectValueOperation } from '@archbase/core';
+import React from 'react';
+export interface ArchbaseJsonSchemaEditorContextValue {
+    handleChange?: (path: string, value: any, operation?: SetNestedObjectValueOperation) => void;
+}
+export declare const ArchbaseJsonSchemaEditorContext: React.Context<ArchbaseJsonSchemaEditorContextValue>;
+export declare const ArchbaseJsonSchemaEditorProvider: React.Provider<ArchbaseJsonSchemaEditorContextValue>;

package/dist/jsonschema/JsonSchemaEditor/ArchbaseJsonSchemaEditor.d.ts

@@ -0,0 +1,9 @@
+import { JSONSchema7 } from '../ArchbaseJsonSchemaEditor.types';
+export * from '../ArchbaseJsonSchemaEditor.types';
+export interface ArchbaseJsonSchemaEditorProps {
+    rootSchema?: JSONSchema7 | undefined;
+    defaultRootSchema?: JSONSchema7 | undefined;
+    onRootSchemaChange?: (schema: JSONSchema7, isValid: boolean) => void;
+    readOnly?: boolean;
+}
+export declare const ArchbaseJsonSchemaEditor: ({ rootSchema, defaultRootSchema, onRootSchemaChange, readOnly, }: ArchbaseJsonSchemaEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/advanced-boolean/index.d.ts

@@ -0,0 +1,2 @@
+import { AdvancedItemStateProps } from '../../ArchbaseJsonSchemaEditor.types';
+export declare const AdvancedBoolean: ({ path, item, }: AdvancedItemStateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/advanced-number/index.d.ts

@@ -0,0 +1,2 @@
+import { AdvancedItemStateProps } from '../../ArchbaseJsonSchemaEditor.types';
+export declare const AdvancedNumber: ({ path, item, }: AdvancedItemStateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/advanced-string/index.d.ts

@@ -0,0 +1,2 @@
+import { AdvancedItemStateProps } from '../../ArchbaseJsonSchemaEditor.types';
+export declare const AdvancedString: ({ path, item, }: AdvancedItemStateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/drop-plus/index.d.ts

@@ -0,0 +1,10 @@
+import { FlexProps } from '@mantine/core';
+import { JSONSchema7 } from '../../ArchbaseJsonSchemaEditor.types';
+export interface DropPlusProps extends FlexProps {
+    itemPath: string;
+    parentPath: string;
+    parent: JSONSchema7;
+    item: JSONSchema7;
+    isReadOnly: boolean;
+}
+export declare const DropPlus: ({ itemPath, parentPath, parent, item, isReadOnly, }: DropPlusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseJsonSchemaEditor } from './ArchbaseJsonSchemaEditor';
+export type { ArchbaseJsonSchemaEditorProps } from './ArchbaseJsonSchemaEditor';

package/dist/jsonschema/JsonSchemaEditor/schema-advanced/index.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema7 } from '../../ArchbaseJsonSchemaEditor.types';
+export interface AdvancedSettingsProps {
+    path: string;
+    item: JSONSchema7;
+}
+export declare const AdvancedSettings: ({ path, item, }: AdvancedSettingsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/schema-array/index.d.ts

@@ -0,0 +1,8 @@
+import { FlexProps } from '@mantine/core';
+import { JSONSchema7 } from '../../ArchbaseJsonSchemaEditor.types';
+export interface SchemaArrayProps extends FlexProps {
+    path: string;
+    jsonSchema: JSONSchema7;
+    isReadOnly: boolean;
+}
+export declare const SchemaArray: ({ path, jsonSchema, isReadOnly, }: SchemaArrayProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/schema-item/index.d.ts

@@ -0,0 +1,11 @@
+import { FlexProps } from '@mantine/core';
+import { JSONSchema7 } from '../../ArchbaseJsonSchemaEditor.types';
+export interface SchemaItemProps extends FlexProps {
+    jsonSchema: JSONSchema7;
+    name: string;
+    itemPath: string;
+    parentPath: string;
+    showadvanced: (item: string) => void;
+    isReadOnly: boolean;
+}
+export declare const SchemaItem: ({ name, showadvanced, jsonSchema, itemPath, parentPath, isReadOnly, }: SchemaItemProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/schema-object/index.d.ts

@@ -0,0 +1,7 @@
+import { JSONSchema7 } from '../ArchbaseJsonSchemaEditor';
+export interface SchemaObjectProps {
+    path: string;
+    jsonSchema: JSONSchema7;
+    isReadOnly: boolean;
+}
+export declare const SchemaObject: ({ path, jsonSchema, isReadOnly, }: SchemaObjectProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/schema-root/index.d.ts

@@ -0,0 +1,8 @@
+import { FlexProps } from '@mantine/core';
+import { JSONSchema7 } from '../../ArchbaseJsonSchemaEditor.types';
+export interface SchemaArrayProps extends FlexProps {
+    path: string;
+    jsonSchema: JSONSchema7;
+    isReadOnly: boolean;
+}
+export declare const SchemaRoot: ({ path, jsonSchema, isReadOnly, }: SchemaArrayProps) => import("react/jsx-runtime").JSX.Element;

package/dist/jsonschema/JsonSchemaEditor/utils.d.ts

@@ -0,0 +1,25 @@
+import { JSONSchema7, JSONSchema7TypeName } from '../ArchbaseJsonSchemaEditor.types';
+export declare const JSONPATH_JOIN_CHAR = ".";
+export declare const isValidSchemaValidator: (schema: JSONSchema7) => boolean;
+export declare enum PropertyType {
+    SIBLING = 0,
+    CHILD = 1
+}
+export declare const StringFormat: {
+    name: string;
+}[];
+export declare const SchemaTypes: string[];
+export declare enum DataType {
+    string = "string",
+    number = "number",
+    array = "arrray",
+    object = "object",
+    boolean = "boolean",
+    integer = "integer"
+}
+export declare const getDefaultSchema: (dataType: DataType, includeSchema?: boolean) => JSONSchema7;
+export declare const random: () => string;
+export declare const handleTypeChange: (newValue: JSONSchema7TypeName, rootChange: boolean) => JSONSchema7;
+export declare const renameKeys: any;
+export declare const deleteKey: (key: string, object: any) => any;
+export declare const isValidEnum: (value: any) => boolean;

package/dist/jsonschema/JsonSchemaEditor/whoops.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const Whoops: () => React.JSX.Element;

package/dist/jsonschema/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseJsonSchemaEditor } from './JsonSchemaEditor/ArchbaseJsonSchemaEditor';
+export type { ArchbaseJsonSchemaEditorProps, JSONSchema7, Schema2 } from './JsonSchemaEditor/ArchbaseJsonSchemaEditor';

package/dist/list/ArchbaseList.context.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseListContextValue<T, ID> {
+    /** Indica se a lista esta desabilitada */
+    disabled?: boolean;
+    /** Fonte de dados da lista (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Function para notificar a lista que o item foi selecionado */
+    handleSelectItem?: (index: number, data: T) => void;
+    /** Id da lista pai */
+    ownerId?: any;
+    /** Cor de fundo do item ativo definido globalmente na lista */
+    activeBackgroundColor?: string;
+    /** Cor da fonte do item ativo definido globalmente na lista */
+    activeColor?: string;
+    /** Alinhamento do item na lista */
+    align?: 'left' | 'right' | 'center';
+    /** Tipo de lista */
+    type?: 'ordered' | 'unordered' | 'none';
+    /** Evento gerado quando o mouse está sobre um item */
+    onItemEnter?: (event: React.MouseEvent, data: any) => void;
+    /** Evento gerado quando o mouse sai de um item */
+    onItemLeave?: (event: React.MouseEvent, data: any) => void;
+}
+declare const ArchbaseListContext: React.Context<ArchbaseListContextValue<any, any>>;
+export declare const ArchbaseListProvider: React.Provider<ArchbaseListContextValue<any, any>>;
+export default ArchbaseListContext;

package/dist/list/ArchbaseList.d.ts

@@ -0,0 +1,104 @@
+import React, { FocusEventHandler } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseListCustomItemProps<T, _ID> {
+    /** Chave */
+    key: string;
+    /** Id do item */
+    id: any;
+    /** Indicador se o Item está ativo */
+    active: boolean;
+    /** Indice dentro da lista */
+    index: number;
+    /** Registro contendo dados de uma linha na lista */
+    recordData: T;
+    /** Indicador se item da lista está desabilitado */
+    disabled: boolean;
+}
+export interface ComponentDefinition {
+    type: React.ElementType;
+    props?: any;
+}
+export interface ArchbaseListProps<T, ID> {
+    /** Cor de fundo do item ativo */
+    activeBackgroundColor?: string;
+    /** Cor do item ativo */
+    activeColor?: string;
+    /** Alinhamento dos itens na lista */
+    align?: 'left' | 'right' | 'center';
+    /** Cor de fundo da lista */
+    backgroundColor?: string;
+    /** Cor do texto da lista */
+    color?: string;
+    /** Altura da lista */
+    height?: number | string;
+    /** Largura da lista */
+    width?: number | string;
+    /** desabilita todos os itens da lista */
+    disabled?: boolean;
+    /** Indicador se os itens da lista devem ser justificados */
+    justify?: 'flex-start' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    /** Evento que ocorre quando um item da lista é selecionado */
+    onSelectListItem?: (index: number, data: any) => void;
+    /** Mostra uma borda ao redor da lista */
+    withBorder?: boolean;
+    /** Cor da borda */
+    borderColor?: string;
+    /** Arredondamento dos cantos da borda */
+    borderRadius?: string | number | undefined;
+    /** Propriedade do objeto de dados que representa o texto a ser apresentado na lista */
+    dataFieldText?: string;
+    /** Propriedade do objeto de dados que representa o ID do item na lista para controle */
+    dataFieldId?: string;
+    /** Indice do item ativo na lista */
+    activeIndex?: number | undefined;
+    /** Evento gerado quando o mouse está sobre um item */
+    onItemEnter?: (event: React.MouseEvent, data: any) => void;
+    /** Evento gerado quando o mouse sai de um item */
+    onItemLeave?: (event: React.MouseEvent, data: any) => void;
+    /** Permite costumizar o style da lista */
+    style?: React.CSSProperties;
+    /** Id da lista */
+    id?: string;
+    /** Fonte de dados a ser usado pela lista (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Filtro a ser aplicado na lista */
+    filter?: string;
+    /** Function a ser aplicada na lista para filtrar os itens */
+    onFilter?: (record: any) => boolean;
+    /** Definições do componente customizado a ser renderizado para um Item da lista */
+    component?: ComponentDefinition;
+    /** Somente componentes <ArchbaseListItem /> */
+    children?: React.ReactNode[];
+    /** Tipo de lista: ol,ul,div */
+    type?: 'ordered' | 'unordered' | 'none';
+    /** Incluir preenchimento à esquerda para compensar a lista do conteúdo principal */
+    withPadding?: boolean;
+    /** Tamanho da fonte do tema ou número para definir o valor */
+    size?: string | number | undefined;
+    /** Ícone que deve substituir o ponto do item da lista */
+    icon?: React.ReactNode;
+    /** Imagem ou source de uma imagem para mostrar no item da lista */
+    image?: React.ReactNode | string;
+    /** Arredondamento da Imagem */
+    imageRadius?: string | number | undefined;
+    /** Altura da imagem */
+    imageHeight?: number | string;
+    /** Largura da Imagem */
+    imageWidth?: number | string;
+    /** Espaçamento entre os valores do item */
+    spacing?: string | number | undefined;
+    /** Centralizar itens com ícone */
+    center?: boolean;
+    /** Lista horizontal */
+    horizontal?: boolean;
+    /** force update list */
+    update?: number;
+    /** Estilo de lista */
+    listStyleType?: React.CSSProperties['listStyleType'];
+    onFocusEnter?: FocusEventHandler<HTMLDivElement> | undefined;
+    onFocusExit?: FocusEventHandler<HTMLDivElement> | undefined;
+}
+export declare function ArchbaseList<T, ID>(props: ArchbaseListProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseList {
+    var displayName: string;
+}

package/dist/list/ArchbaseListItem.d.ts

@@ -0,0 +1,59 @@
+import { ReactNode } from 'react';
+export interface ArchbaseListItemProps<T, ID> {
+    /** Indicador se o item está ativo(selecionado) */
+    active: boolean;
+    /** Cor de fundo do item */
+    activeBackgroundColor?: string;
+    /** Cor do item se ele estiver ativo */
+    activeColor?: string;
+    /** Alinhamento do texto do item */
+    align?: 'left' | 'right' | 'center';
+    /** Cor de fundo do item não selecionado */
+    backgroundColor?: string;
+    /** Texto do item */
+    caption: string;
+    /** Cor da fonte do item */
+    color: string;
+    /** Filhos do item */
+    children?: ReactNode;
+    /** Indicador se o item está desabilitado */
+    disabled: boolean;
+    /** Icone a ser apresentado ao lado esquerdo do item */
+    icon?: ReactNode;
+    /** Id do item */
+    id: any;
+    /** Posição do item dentro da lista */
+    index: number;
+    /** Imagem a ser apresentada ao lado esquerdo do item */
+    image?: ReactNode | string;
+    /** Arredondamento da Imagem */
+    imageRadius?: string | number | undefined;
+    /** Altura da imagem */
+    imageHeight?: number | string;
+    /** Largura da Imagem */
+    imageWidth?: number | string;
+    /** Indicador se o conteúdo do item deve ser justificado */
+    justify?: 'flex-start' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    /** Indicador se o item deve ter uma borda */
+    withBorder?: boolean;
+    /** Cor da borda */
+    borderColor?: string;
+    /** Arredondamento dos cantos da borda */
+    borderRadius?: string | number | undefined;
+    /** Dados do item a ser apresentado */
+    recordData?: T;
+    /** Indicador se o item está visivel na lista */
+    visible?: boolean;
+    /** Espaçamento entre os valores do item */
+    spacing?: string | number | undefined;
+}
+export declare function ArchbaseListItem<T, ID>({ active, activeBackgroundColor, activeColor, backgroundColor, caption, color, disabled, icon, id, index, image, imageRadius, imageHeight, imageWidth, justify, children, recordData, spacing, }: ArchbaseListItemProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseListItem {
+    var defaultProps: {
+        align: string;
+        justify: boolean;
+        showBorder: boolean;
+        disabled: boolean;
+    };
+    var displayName: string;
+}

package/dist/list/index.d.ts

@@ -0,0 +1,8 @@
+import ArchbaseListContext from './ArchbaseList.context';
+export { ArchbaseList } from './ArchbaseList';
+export type { ArchbaseListProps, ArchbaseListCustomItemProps } from './ArchbaseList';
+export { ArchbaseListItem } from './ArchbaseListItem';
+export type { ArchbaseListItemProps } from './ArchbaseListItem';
+export type { ArchbaseListContextValue } from './ArchbaseList.context';
+export { ArchbaseListContext };
+export * from './treeview';

package/dist/list/treeview/ArchbaseTreeView.d.ts

@@ -0,0 +1,44 @@
+import React, { ReactNode } from 'react';
+import { ArchbaseTreeNode } from './ArchbaseTreeView.types';
+export interface ArchbaseTreeViewProps {
+    id: string;
+    selectable?: boolean;
+    color?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    hoverColor?: string;
+    hoverBackgroundColor?: string;
+    focusedColor?: string;
+    focusedBackgroundColor?: string;
+    selectedColor?: string;
+    selectedBackgroundColor?: string | 'auto';
+    iconColor?: string;
+    iconBackgroundColor?: string;
+    enableLinks?: boolean;
+    highlightSelected?: boolean;
+    withBorder?: boolean;
+    showTags?: boolean;
+    selectChildrenOnParentSelect?: boolean;
+    singleSelect?: boolean;
+    nodes?: ArchbaseTreeNode[];
+    onDoubleClick?: (dataSource: ArchbaseTreeNode[], node: ArchbaseTreeNode) => void;
+    onClick?: () => void;
+    onFocusedNode?: (node: ArchbaseTreeNode) => void;
+    onLoosedFocusNode?: (focused: ArchbaseTreeNode) => void;
+    onSelectedNode?: (dataSource: ArchbaseTreeNode[], node: ArchbaseTreeNode, selectedNodes: ArchbaseTreeNode[]) => void;
+    onUnSelectedNode?: (dataSource: ArchbaseTreeNode[], node: ArchbaseTreeNode, selectedNodes: ArchbaseTreeNode[]) => void;
+    onRemovedNode?: (dataSource: ArchbaseTreeNode[]) => void;
+    onLoadDataSource?: (node: ArchbaseTreeNode) => Promise<ArchbaseTreeNode[]>;
+    onAddedNode?: (node: ArchbaseTreeNode, dataSource: ArchbaseTreeNode[]) => void;
+    onExpandedNode?: (dataSource: ArchbaseTreeNode[], expandedNodes: ArchbaseTreeNode[]) => void;
+    onCollapsedNode?: (dataSource: ArchbaseTreeNode[], expandedNodes: ArchbaseTreeNode[]) => void;
+    onChangedDataSource?: (dataSource: ArchbaseTreeNode[]) => void;
+    dataSource: ArchbaseTreeNode[];
+    focusedNode?: ArchbaseTreeNode;
+    style?: React.CSSProperties;
+    height?: string;
+    width?: string;
+    customRenderText?: (node: ArchbaseTreeNode) => ReactNode;
+    update?: number;
+}
+export declare const ArchbaseTreeView: React.FC<ArchbaseTreeViewProps>;

package/dist/list/treeview/ArchbaseTreeView.types.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+export interface ArchbaseTreeNode {
+    id: string;
+    nodes?: ArchbaseTreeNode[];
+    parentNode?: ArchbaseTreeNode;
+    isleaf?: boolean;
+    state: {
+        selected: boolean;
+        expanded: boolean;
+        loading: boolean;
+    };
+    text: string;
+    icon?: ReactNode;
+    color?: string;
+    backgroundColor?: string;
+    image?: string;
+    data?: any;
+    type?: string;
+}
+export interface ArchbaseTreeViewOptions {
+    selectable: boolean;
+    color: string;
+    iconColor: string;
+    iconBackgroundColor?: string;
+    backgroundColor: string;
+    borderColor: string;
+    hoverColor: string;
+    hoverBackgroundColor?: string;
+    highlightSelected: boolean;
+    selectedColor: string;
+    selectedBackgroundColor: string;
+    focusedColor: string;
+    focusedBackgroundColor: string;
+    id: string;
+    enableLinks: boolean;
+    withBorder: boolean;
+    showTags: boolean;
+    selectChildrenOnParentSelect?: boolean;
+    singleSelect?: boolean;
+}

package/dist/list/treeview/ArchbaseTreeViewItem.d.ts

@@ -0,0 +1,19 @@
+import React, { ReactNode } from 'react';
+import { ArchbaseTreeNode, ArchbaseTreeViewOptions } from './ArchbaseTreeView.types';
+export interface ArchbaseTreeViewItemProps {
+    id: string;
+    node: ArchbaseTreeNode;
+    options: ArchbaseTreeViewOptions;
+    level: number;
+    onLoadDataSource: (id: string) => void;
+    onSelectedStatusChanged: (id: string, selected: boolean) => void;
+    onExpandedCollapsedChanged: (id: string, expanded: boolean) => void;
+    onFocusedChanged: (id: string) => void;
+    getFocused: () => ArchbaseTreeNode | undefined;
+    onNodeDoubleClicked: (id: string, selected: boolean) => void;
+    addNode: (id: string, text: string) => void;
+    removeNode: (id: string) => void;
+    customRenderText?: (node: ArchbaseTreeNode) => ReactNode;
+    update: number;
+}
+export declare const ArchbaseTreeViewItem: React.FC<ArchbaseTreeViewItemProps>;

package/dist/list/treeview/index.d.ts

@@ -0,0 +1,5 @@
+export type { ArchbaseTreeViewProps } from './ArchbaseTreeView';
+export type { ArchbaseTreeViewItemProps } from './ArchbaseTreeViewItem';
+export { ArchbaseTreeView } from './ArchbaseTreeView';
+export { ArchbaseTreeViewItem } from './ArchbaseTreeViewItem';
+export type { ArchbaseTreeNode, ArchbaseTreeViewOptions } from './ArchbaseTreeView.types';